float(object)

float函数可以将一个十进制整数、十进制浮点数字符串或布尔值转化为十进制浮点数。

print(float(3))  #十进制整数转换为十进制浮点数
print(float(-5))
print(float('14.6')) #十进制字符串转换为十进制浮点数
print(float('-90.3'))
print(float(True))  #布尔值转换为浮点数
print(float(False))
print(float(0.0))

输出:
3
-5
14.6
-90.3
True
False
0.0

fomart

  • 基本语法是通过 {} 和 : 来代替以前的 % 。
  • format 函数可以接受不限个参数,位置可以不按顺序。
  • 字符串的参数使用{NUM}进行表示,0, 表示第一个参数,1, 表示第二个参数, 以后顺次递加;
  • 使用":", 指定代表元素需要的操作, 如":.3"小数点三位, ":8"占8个字符空间等;
fomart格式转化

数字       格式    输出       描述
3.1415926   {:.2f}    3.14      保留小数点后两位
3.1415926   {:+.2f}   3.14      带符号保留小数点后两位  
-1          {:+.2f}   -1        带符号保留小数点后两位
2.71828     {:.0f}    3         不带小数
1000000     {:,}      1,000,000 以逗号分隔的数字格式
0.25        {:.2%}    25.00%    百分比格式
1000000000  {:.2e}    1.00E+09  指数记法
25          {0:b}     11001 转换成二进制
25          {0:d}     25    转换成十进制
25          {0:o}     31    转换成八进制
25          {0:x}     19    转换成十六进制
5           {:0>2}    05    数字补零(填充左边, 宽度为2)
5           {:x<4}    5xxx  数字补x (填充右边, 宽度为4)
10          {:x^4}    x10x  数字补x (填充两边,优先左边, 宽度为4)
13          {:10}     13    右对齐 (默认, 宽度为10)
13          {:<10}    13    左对齐 (宽度为10)
13          {:^10}    13    中间对齐 (宽度为10)
位置填充字符串
age = 25
name = 'Caroline'
# 0和1表示位置,可省略,省略后按照顺序依次赋值

print('{0} is {1} years old. '.format(name, age))  # 输出参数
print('{0} is a girl. '.format(name))
print('{0:.3} is a decimal. '.format(1 / 3))  # 小数点后三位
print('{0:_^11} is a 11 length. '.format(name))  # 使用_补齐空位
print('{first} is as {second}. '.format(first=name, second='Wendy'))  # 别名替换

输出:
Caroline is 25 years old. 
Caroline is a girl. 
0.333 is a decimal. 
_Caroline__ is a 11 length. 
Caroline is as Wendy. 
key填充:
obj = 'world'
name = 'python'
print('hello, {obj} ,i am {name}'.format(obj=obj, name=name))  # 输入结果:hello, world ,i am python
列表填充:
list=['world','python']
print('hello {names[0]}  i am {names[1]}'.format(names=list))  # 输出结果:hello world  i am python
print('hello {0[0]}  i am {0[1]}'.format(list))   #输出结果:hello world  i am python
dict = {'obj': 'world', 'name': 'python'}
print('hello {names[obj]} i am {names[name]}'.format(names=dict))  # hello world i am python
注意:访问字典的key,不用引号
类属性填充:
class Names():
    obj='world'
    name='python'

print('hello {names.obj} i am {names.name}'.format(names=Names))#输入结果hello world i am python
使用魔法参数:
args = [‘,’,’inx’]
kwargs = {‘obj’: ‘world’, ‘name’: ‘python’}
print(‘hello {obj} {} i am {name}’.format(*args, **kwargs))#输入结果:hello world , i am python
注意:魔法参数跟你函数中使用的性质是一样的:这里format(*args, **kwargs)) 等价于:format(‘,’,’inx’,obj = ‘world’,name = ‘python’)
format作为函数变量
name = 'InX'
hello = 'hello,{} welcome to python world!!!'.format #定义一个问候函数
hello(name) #输入结果:hello,inx welcome to python world!!!
格式化datetime:
from datetime import datetime
now=datetime.now()
print '{:%Y-%m-%d %X}'.format(now) # 输出结果:2017-07-24 16:51:42

globals()

globals() 函数会以字典类型返回当前位置的全部全局变量

这个方法一般用于将A函数内的变量添加到全局变量里
B函数可以通过该函数获取该字典里面的变量

示例:
a = "hello"


class Yoo(object):
    name = "zhangsan"
    age = 14

    def add(self, x, b):
        print(locals())
        globals()['x'] = x
        return x + b


print(globals())
y = Yoo()
y.add(1, 2)
print(globals())
value = globals()['x']
print(value)

输出结果:

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001B7E98F6CD0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'G:\\appium_testcases\\MeetYou_Project\\test_demo.py', '__cached__': None, 'a': 'hello', 'Yoo': <class '__main__.Yoo'>}

{'self': <__main__.Yoo object at 0x000001B7FCA6EFD0>, 'x': 1, 'b': 2}

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001B7E98F6CD0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'G:\\appium_testcases\\MeetYou_Project\\test_demo.py', '__cached__': None, 'a': 'hello', 'Yoo': <class '__main__.Yoo'>, 'y': <__main__.Yoo object at 0x000001B7FCA6EFD0>, 'x': 1}

1

根据结果可以看出,原本的globals中没显示'x': 1字段,通过在add函数中把局部变量转变成全局变量了,而后可以在全局变量中通过字典方式取值

input()

#输入函数input
present=input('请输入一个数据')  # 输入66
print(present,type(present))

输出:
请输入一个数据66
66 <class 'str'>

input的返回结果默认为str类型

int()

int() 函数用于将一个字符串或数字转换为整型。

class int(x, base=10)

x -- 字符串或数字。
base -- 进制数,默认十进制。

print(int(3))  # 整形
print(int(3.6))  # 浮点型,向下匹配
print(int('12', 16))  # 如果需要用到base参数,前面x变量需要输入字符串类型,转16进制
print(int('10', 8))  # 转8进制
print(int())
print(int(0))

输出:
3
3
18
8
0
0

len()

返回对象的长度(元素个数)。实参可以是序列(如 string、bytes、tuple、list 或 range 等)或集合(如 dictionary、set 或 frozen set 等)。

str1 = "jin tian tian qi bu cuo"
dict1 = {1: "开始", 2: "结束"}
list1 = ["hi  ", "wo   ", "men"]

print(len(str1))  # 23  空格也算一个长度
print(len(dict1)) # 2
print(len(list1)) # 3  列表中整体算一个长度

map()

它接收一个函数 f 和一个 list,并通过把函数 f 依次作用在 list 的每个元素上,得到一个新的 list 并返回。

def f(x):
    return x * x

print(list(map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])))

输出:
[1, 4, 9, 16, 25, 36, 49, 64, 81]

传递 Lambda:

list(map(lambda x1:x1*5,[1,2,3]))

输出:
[5,10,15]

max()

返回可迭代对象中最大的元素,或者返回两个及以上实参中最大的
max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])

示例:
"""
传入多个参数取最大值(元组、列表、集合)
"""
print(max([3, 6, 2, 1, 55, 77, 2131, 24, 31]))  # 2131

"""
传入可迭代对象时,取其元素最大值
"""
s = '12345'  #2、传入可迭代对象时,取其元素最大值
print(max(s))  # 5

"""
传入可迭代对象为空时,必须指定参数default,用来返回默认值
"""
print(max((),default=1))# 3、传入可迭代对象为空时,必须指定参数default,用来返回默认值1
print(max(()))#报错

next()

next() 返回迭代器的下一个项目。

next() 函数要和生成迭代器的 iter() 函数一起使用。

next(iterable[, default]) - iterable -- 可迭代对象 - default -- 可选,用于设置在没有下一个元素时返回该默认值,如果不设置,又没有下一个元素则会触发 StopIteration 异常。

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break


输出:
1
2
3
4
5


it = iter([1, 2, 5, 4, 3])
while True:
    x = next(it, 'a')
    print(x)
    if x == 'a':
        break

输出:
1
2
5
4
3
a

open()

open(file, mode='r', buffering=- 1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

  • file 表示打开文件的路径(可绝对路径/相对路径)
  • mode 表示操作文件的模式(包含读写)
  • buffering 可选参数,用于指定对文件做读写操作时,是否使用缓冲区
  • encoding 表示的是返回的数据采用何种编码,一般采用utf8或者gbk
  • errors 取值一般有strict,ignore,当取strict的时候,字符编码出现问题的时候,会报错,当取ignore的时候,编码出现问题,程序会忽略而过,继续执行下面的程序。
  • newline可以取的值有None, \n, \r, '', ‘\r\n' ,用于区分换行符,但是这个参数只对文本模式有效
  • closefd的取值,是与传入的文件参数有关,默认情况下为True,传入的file参数为文件的文件名,取值为False的时候,file只能是文件描述符,什么是文件描述符,就是一个非负整数,在Unix内核的系统中,打开一个文件,便会返回一个文件描述符。

mode基本取值

r、w、a为打开文件的基本模式,对应着只读、只写、追加模式;

b、t、+、U这四个字符,与以上的文件打开模式组合使用,二进制模式,文本模式,读写模式、通用换行符,根据实际情况组合使用

常见mode取值组合

模式 作用 注意事项
r 只读模式打开文件,读文件内容的指针会放在文件的开头。 操作的文件必须存在。
rb 以二进制格式、采用只读模式打开文件,读文件内容的指针位于文件的开头,一般用于非文本文件,如图片文件、音频文件等。 操作的文件必须存在。
r+ 打开文件后,既可以从头读取文件内容,也可以从开头向文件中写入新的内容,写入的新内容会覆盖文件中等长度的原有内容。 操作的文件必须存在。
rb+ 以二进制格式、采用读写模式打开文件,读写文件的指针会放在文件的开头,通常针对非文本文件(如音频文件)。 操作的文件必须存在。
w 以只写模式打开文件,若该文件存在,打开时会清空文件中原有的内容。 若文件存在,会清空其原有内容(覆盖文件);反之,则创建新文件。
wb 以二进制格式、只写模式打开文件,一般用于非文本文件(如音频文件) 若文件存在,会清空其原有内容(覆盖文件);反之,则创建新文件。
w+ 打开文件后,会对原有内容进行清空,并对该文件有读写权限。 若文件存在,会清空其原有内容(覆盖文件);反之,则创建新文件。
wb+ 以二进制格式、读写模式打开文件,一般用于非文本文件 若文件存在,会清空其原有内容(覆盖文件);反之,则创建新文件。
a 以追加模式打开一个文件,对文件只有写入权限,如果文件已经存在,文件指针将放在文件的末尾(即新写入内容会位于已有内容之后);反之,则会创建新文件。
ab 以二进制格式打开文件,并采用追加模式,对文件只有写权限。如果该文件已存在,文件指针位于文件末尾(新写入文件会位于已有内容之后);反之,则创建新文件。
a+ 以读写模式打开文件;如果文件存在,文件指针放在文件的末尾(新写入文件会位于已有内容之后);反之,则创建新文件。
ab+ 以二进制模式打开文件,并采用追加模式,对文件具有读写权限,如果文件存在,则文件指针位于文件的末尾(新写入文件会位于已有内容之后);反之,则创建新文件。

open()是否需要缓冲区

通常情况下、建议大家在使用 open() 函数时打开缓冲区,即不需要修改 buffing 参数的值。

如果 buffing 参数的值为 0(或者 False),则表示在打开指定文件时不使用缓冲区;如果 buffing 参数值为大于 1 的整数,该整数用于指定缓冲区的大小(单位是字节);如果 buffing 参数的值为负数,则代表使用默认的缓冲区大小。

为什么呢?原因很简单,目前为止计算机内存的 I/O 速度仍远远高于计算机外设(例如键盘、鼠标、硬盘等)的 I/O 速度,如果不使用缓冲区,则程序在执行 I/O 操作时,内存和外设就必须进行同步读写操作,也就是说,内存必须等待外设输入(输出)一个字节之后,才能再次输出(输入)一个字节。这意味着,内存中的程序大部分时间都处于等待状态。

而如果使用缓冲区,则程序在执行输出操作时,会先将所有数据都输出到缓冲区中,然后继续执行其它操作,缓冲区中的数据会有外设自行读取处理;同样,当程序执行输入操作时,会先等外设将数据读入缓冲区中,无需同外设做同步读写操作。