├── 1.txt ├── README.md ├── abs函数详解.py ├── all函数详解.py ├── any函数详解.py ├── ascii函数详解.py ├── bin函数详解.py ├── bool函数详解.py ├── bytes函数详解.py ├── challable函数详解.py ├── chr函数详解.py ├── classmethod修饰符详解.py ├── complex函数详解.py ├── complie函数详解.py ├── delattr函数详解.py ├── dict函数详解.py ├── dir函数详解.py ├── divmod函数详解.py ├── enumerate函数详解.py ├── eval函数详解.py ├── exec函数详解.py ├── filter函数详解.py ├── flaot函数详解.py ├── format函数详解.py ├── frozenset函数详解.py ├── getattr函数详解.py ├── globals函数详解.py ├── hasattr函数详解.py ├── hash函数详解.py ├── hex函数详解.py ├── id函数详解.py ├── input函数详解.py ├── int函数详解.py ├── isinstance函数详解.py ├── issubclass函数详解.py ├── iter函数详解.py ├── lambda函数详解.py ├── len函数详解.py ├── list函数详解.py ├── locals函数详解.py ├── map函数详解.py ├── max函数详解.py ├── min函数详解.py ├── next函数详解.py ├── oct函数详解.py ├── open函数详解.py ├── ord函数详解.py ├── pow函数详解.py ├── property函数详解.py ├── range函数详解.py ├── reduce函数详解.py ├── repr函数详解.py ├── reversed函数详解.py ├── round函数详解.py ├── setattr函数详解.py ├── set函数详解.py ├── slice函数详解.py ├── sorted函数详解.py ├── staticmethod函数详解.py ├── str函数详解.py ├── sum函数详解.py ├── vars函数详解.py └── zip函数详解.py /1.txt: -------------------------------------------------------------------------------- 1 | ltf 2 | zhongguo 3 | shanxi 4 | yuncheng 5 | 男 6 | 20 -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Python_funs 2 | Python3基本内置函数 3 | 4 | 总结了一些Python3的基本内置函数 5 | 6 | 希望大家可以学习到一些知识 7 | -------------------------------------------------------------------------------- /abs函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | abs() 函数返回数字的绝对值。 3 | 绝对值：absolute 4 | 正如字面上的意思，可以返回一个绝对值 5 | ''' 6 | import math 7 | print('abs(45)的值:',abs(45)) 8 | print('abs(-45)的值:',abs(-45)) 9 | print('abs(45+23)的值:',abs(45+23)) 10 | print('abs(math.pi)的值:',abs(math.pi)) 11 | 12 | print(help(abs)) 13 | ''' 14 | 运行结果： 15 | abs(45)的值: 45 16 | abs(-45)的值: 45 17 | abs(45+23)的值: 68 18 | abs(math.pi)的值: 3.141592653589793 19 | Help on built-in function abs in module builtins: 20 | 21 | abs(x, /) 22 | Return the absolute value of the argument. 23 | 24 | None 25 | 26 | 在python2 里还可以输出 print "abs(119L) : ", abs(119L) 不过python3中abs函数只能输入int型 不然会报错 27 | ''' 28 | -------------------------------------------------------------------------------- /all函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。 3 | 元素除了是 0、空、FALSE 外都算 TRUE。 4 | 语法 5 | 以下是 all() 方法的语法: 6 | all(iterable) 7 | 参数 8 | iterable -- 元组或列表。 9 | 返回值 10 | 如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False； 11 | 注意：空元组、空列表返回值为True，这里要特别注意。 12 | ''' 13 | print(all(['a','b','c',''])) #列表存在一个为空的元素，返回False 14 | print(all(['a','b','c','d'])) #列表都有元素，返回True 15 | print(all([0,1,2,3,4,5,6])) #列表里存在为0的元素 返回False 16 | 17 | print(all(('a','b','c',''))) #元组存在一个为空的元素，返回Fasle 18 | print(all(('a','b','c','d'))) #元组都有元素，返回True 19 | print(all((0,1,2,3,4,5))) #元组存在一个为0的元素，返回Fasle 20 | 21 | print(all([])) #空列表返回 True 22 | print(all(())) #空元组返回 True -------------------------------------------------------------------------------- /any函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。 3 | 元素除了是 0、空、FALSE 外都算 TRUE。 4 | 语法 5 | 以下是 any() 方法的语法: 6 | any(iterable) 7 | 参数 8 | iterable -- 元组或列表。 9 | 返回值 10 | 如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。 11 | ''' 12 | print(any(['a','b','c',''])) #列表存在一个为空的元素，返回True 13 | print(any(['a','b','c','d'])) #列表都不为空，返回True 14 | print(any([0,'',False])) #列表里的元素全为 0,'',False 返回False 15 | 16 | print(any(('a','b','c',''))) #元组存在一个为空的元素，返回True 17 | print(any(('a','b','c','d'))) #元组都有元素，返回True 18 | print(any((0,'',False))) #元组里的元素全为 0,'',False 返回False 19 | 20 | print(any([])) #空列表返回 False 21 | print(any(())) #空元组返回 False -------------------------------------------------------------------------------- /ascii函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | ascii() 函数类似 repr() 函数, 返回一个表示对象的字符串, 3 | 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符。 4 | 生成字符串类似 Python2 版本中 repr() 函数的返回值。 5 | 语法 6 | 以下是 ascii() 方法的语法: 7 | ascii(object) 8 | 9 | 参数 10 | object -- 对象。 11 | 12 | 返回值 13 | 返回字符串 14 | ''' 15 | print(ascii('uiatfu')) 16 | 17 | #报错 SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in position 427-428: truncated \xXX escape 18 | #不知道为何 19 | -------------------------------------------------------------------------------- /bin函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 函数原型 3 | bin(x) 4 | 参数解释 5 | x 6 | 整数型，参数不可为空。 7 | 返回值 8 | 字符串类型，二进制整数。 9 | 函数说明 10 | 将一个整数转化为一个二进制整数，并以字符串的类型返回。 11 | ''' 12 | print(bin(12)) #输出12的二进制 0b1100 13 | print(bin(-120)) #输出-12的二进制 -0b1111000 14 | print(type(bin(12))) #输出bin(12) 的类型 所以不能直接计算 15 | 16 | print(int(bin(10),base=2)+int(bin(20),base=2)) #输出 30 17 | 18 | #base 参数不可为空 为空默认参数为10进制 会报错 ValueError: invalid literal for int() with base 10: '0b1010' 19 | 20 | #当然了，参数不仅可以接受十进制整数，八进制、十六进制也是可以的，只要是int型数据就合法。 21 | 22 | print(bin(0b10010)) #输出0b10010 23 | print(bin(0o1357)) #输出0b1011101111 24 | print(bin(0x2d9)) #输出0b1011011001 -------------------------------------------------------------------------------- /bool函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。 4 | bool 是 int 的子类。 5 | 语法 6 | 以下是 bool() 方法的语法: 7 | class bool([x]) 8 | 参数 9 | x -- 要进行转换的参数。 10 | 返回值 11 | 返回 Ture 或 False。 12 | ''' 13 | print(bool(0)) #返回False 14 | print(bool(1)) #返回True 15 | print(bool(True)) #返回True 16 | print(bool(False)) #返回False 17 | print(bool('')) #返回False 18 | 19 | 20 | #0,False,'', 空字符串返回Fasle -------------------------------------------------------------------------------- /bytes函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。 4 | 它是 bytearray 的不可变版本。 5 | 6 | 语法 7 | 以下是 bytes 的语法: 8 | class bytes([source[, encoding[, errors]]]) 9 | 参数 10 | 如果 source 为整数，则返回一个长度为 source 的初始化数组； 11 | 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列； 12 | 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数； 13 | 如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。 14 | 如果没有输入任何参数，默认就是初始化数组为0个元素。 15 | 返回值 16 | 返回一个新的 bytes 对象。 17 | 18 | 将一个字符串转换成字节类型 19 | ''' 20 | print(bytes('python',encoding='utf-8')) #输出b'python' 21 | print(bytes('张三',encoding='utf-8')) #输出b'\xe5\xbc\xa0\xe4\xb8\x89' 22 | 23 | print(bytes([1,2,3,4])) #输出b'\x01\x02\x03\x04' 24 | print(bytes('hello','ascii')) #输出b'hello' 25 | print(type(bytes([1,2,3]))) #输出 26 | -------------------------------------------------------------------------------- /challable函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | challable()　　判断对象是否可以被调用， 3 | 能被调用的对象就是一个callables对象， 4 | 比如函数和带有__call__()的实例 5 | ''' 6 | 7 | print(callable(max)) #输出True 8 | print(callable([1,2,3])) #输出Fasle 9 | print(callable(None)) #输出Fasle 10 | print(callable('str')) #输出Fasle 11 | 12 | 13 | def fn(x): 14 | return x*x 15 | print(callable(fn)) #输出True 证明自定义的函数也可以 -------------------------------------------------------------------------------- /chr函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 查看十进制数对应的ASCII码值 3 | 描述 4 | chr() 用一个整数作参数，返回一个对应的字符。 5 | 语法 6 | 以下是 chr() 方法的语法: 7 | chr(i) 8 | 参数 9 | i -- 可以是 10 进制也可以是 16 进制的形式的数字，数字范围为 0 到 1,114,111 (16 进制为0x10FFFF)。 10 | 返回值 11 | 返回值是当前整数对应的 ASCII 字符。 12 | ''' 13 | 14 | #print(chr(-1)) #报错 ValueError: chr() arg not in range(0x110000) 超出范围 不能小于0 15 | 16 | print(chr(0x30)) #输出 0 17 | print(chr(97)) #输出 a 18 | print(chr(8364)) #输出 € 19 | -------------------------------------------------------------------------------- /classmethod修饰符详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | classmethod 修饰符对应的函数不需要实例化，不需要 self 参数， 4 | 但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。 5 | 语法 6 | classmethod 语法： 7 | classmethod 8 | 参数 9 | 无。 10 | 返回值 11 | 返回函数的类方法。 12 | ''' 13 | 14 | class Stud: 15 | num=1 16 | def fn1(self): 17 | print('方法一') 18 | @classmethod 19 | def fn2(cls): 20 | print('方法二') #输出 方法二 21 | print(cls.num) #调用类的实例化对象 22 | cls().fn1() #调用类的方法 23 | 24 | Stud.fn2() #输出 方法二 不需要实例化 25 | 26 | print('===='*10) 27 | object=Stud() 28 | object.fn1() #输出 方法一 需要实例化 29 | -------------------------------------------------------------------------------- /complex函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。 4 | 如果第一个参数为字符串，则不需要指定第二个参数。。 5 | 语法 6 | complex 语法： 7 | class complex([real[, imag]]) 8 | 参数说明： 9 | real -- int, long, float或字符串； 10 | imag -- int, long, float； 11 | 返回值 12 | 返回一个复数。 13 | ''' 14 | 15 | print(complex(1,2)) #输出 (1+2j) 16 | print(complex(1)) #输出 (1+0j) 17 | print(complex('2')) #输出 (2+0j) 18 | 19 | # 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错 20 | print(complex('2+3j')) #输出 (2+3j) 21 | 22 | print(complex(1.2,3.4)) #输出 (1.2+3.4j) -------------------------------------------------------------------------------- /complie函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | complie()　　将字符串编译成python能识别或可以执行的代码，也可以将文字读成字符串再编译 3 | 4 | 1 compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1) 5 | 2 将source编译为代码或者AST对象。代码对象能过通过exec语句来执行或者eval()进行求值。 6 | 3 参数source：字符串或者AST（abstract syntax trees）对象。 7 | 4 参数filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。 8 | 5 参数model：指定编译代码的种类。可以指定'exec', 'eval', 'single'。 9 | 6 参数flag和dont_inherit：这两个参数为可选参数。 10 | ''' 11 | 12 | s="print('hello world')" 13 | r=compile(s,'hello','exec') 14 | print(r) 15 | 16 | #输出结果： 17 | # at 0x000002EBD335CF60, file "hello", line 1> 18 | 19 | -------------------------------------------------------------------------------- /delattr函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述： 3 | delattr函数用于删除属性 4 | delattr(x,'foobar)相当于del x.foobar 5 | 语法： 6 | setattr(object,name) 7 | 参数： 8 | object--对象 9 | name--必须是对象的属性 10 | 返回值： 11 | 无 12 | ''' 13 | 14 | class People(): 15 | sex='男' 16 | def __init__(self,name): 17 | self.name=name 18 | def peopleinfo(self): 19 | print('欢迎%s访问'%self.name) 20 | 21 | delattr(People,'sex') #等同于 del People.sex 22 | print(People.__dict__) 23 | 24 | #输出 {'__module__': '__main__', '__init__': , 'peopleinfo': , '__dict__': , '__weakref__': , '__doc__': None} 25 | 26 | class Foo: 27 | def run(self): 28 | while True: 29 | cmd=input('cmd>>: ').strip() 30 | if hasattr(self,cmd): 31 | func=getattr(self,cmd) 32 | func() 33 | def download(self): 34 | print('download....') 35 | def upload(self): 36 | print('upload...') 37 | obj=Foo() 38 | obj.run() -------------------------------------------------------------------------------- /dict函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | dict() 函数用于创建一个字典。 4 | 语法 5 | dict 语法： 6 | class dict(**kwarg) 7 | class dict(mapping, **kwarg) 8 | class dict(iterable, **kwarg) 9 | 参数说明： 10 | **kwargs -- 关键字 11 | mapping -- 元素的容器。 12 | iterable -- 可迭代对象。 13 | 返回值 14 | 返回一个字典。 15 | ''' 16 | 17 | print(dict()) #创建空字典 18 | dict1=dict(a='a', b='b', t='t') #传入关键字 构建字典 19 | print(dict1) #输出 {'a': 'a', 'b': 'b', 't': 't'} 20 | 21 | dict2=dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函数方式来构造字典 22 | print(dict2) #输出 {'one': 1, 'two': 2, 'three': 3} 23 | 24 | dict3=dict([('one', 1), ('two', 2), ('three', 3)]) # 可迭代对象方式来构造字典 25 | print(dict3) #输出 {'one': 1, 'two': 2, 'three': 3} 26 | -------------------------------------------------------------------------------- /dir函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。 3 | 语法 4 | dir 语法： 5 | dir([object]) 6 | 参数说明： 7 | object -- 对象、变量、类型。 8 | 返回值 9 | 返回模块的属性列表。 10 | ''' 11 | 12 | print(dir()) #获得当前模块的属性列表 13 | #输出 ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__'] 14 | print(dir([])) #获得列表的方法 15 | #输出 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__ 16 | print(dir(str)) #获得字符串的方法 17 | #输出 ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'] 18 | print(dir(dict)) #获得字典的方法 19 | #输出 ['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values'] 20 | 21 | def update_func(var): 22 | print("var 的内存地址:", id(var)) 23 | var += [4] 24 | 25 | lst_1 = [1, 2, 3] 26 | 27 | print(dir()) #输出 ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'lst_1', 'update_func'] 28 | 29 | class Shape: 30 | def __dir__(self): 31 | return ['area', 'perimeter', 'location'] 32 | 33 | s = Shape() 34 | print(dir(s)) #输出 ['area', 'location', 'perimeter'] 35 | 36 | #参考网页 https://www.yuzhi100.com/tutorial/python3/python3-neizhihanshu-dir -------------------------------------------------------------------------------- /divmod函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。 3 | 在 python 2.3 版本之前不允许处理复数。 4 | 函数语法 5 | divmod(a, b) 6 | 参数说明： 7 | a: 数字 8 | b: 数字 9 | ''' 10 | print(divmod(20,4)) #返回 (5, 0) 11 | print(divmod(7,2)) #返回 (3, 1) 12 | print(divmod(8,2)) #返回 (4, 0) 13 | #print(divmod(1+2j,1+0.5j)) 14 | #报错 TypeError: can't take floor or mod of complex number. -------------------------------------------------------------------------------- /enumerate函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | enumerate是翻译过来是枚举的意思，看下它的方法原型： 3 | enumerate(sequence, start=0)，返回一个枚举对象。 4 | sequence必须是序列或迭代器iterator，或者支持迭代的对象。 5 | enumerate()返回对象的每个元素都是一个元组， 6 | 每个元组包括两个值，一个是计数，一个是sequence的值， 7 | 计数是从start开始的，start默认为0。 8 | --------------------- 9 | ''' 10 | a=["q","w","e","r"] 11 | c=enumerate(a) 12 | for i in c: 13 | print(i) 14 | 15 | ''' 16 | 输出如下: 17 | (0, 'q') 18 | (1, 'w') 19 | (2, 'e') 20 | (3, 'r') 21 | ''' 22 | 23 | a=["w","a","s","d"] 24 | #这里加了个参数2，代表的是start的值 25 | c=enumerate(a,2) 26 | for i in c: 27 | print(i) 28 | ''' 29 | 输出如下： 30 | (2, 'w') 31 | (3, 'a') 32 | (4, 's') 33 | (5, 'd') 34 | ''' 35 | 36 | a=["q","w","e","r"] 37 | #创建一个空字典 38 | b=dict() 39 | #这里i表示的是索引，item表示的是它的值 40 | for i,item in enumerate(a): 41 | b[i]=item 42 | print(b) #输出 {0: 'q', 1: 'w', 2: 'e', 3: 'r'} 43 | 44 | for i,j in enumerate('abc'): 45 | print(i,j) 46 | #输出结果 47 | # 0 a 48 | # 1 b 49 | # 2 c -------------------------------------------------------------------------------- /eval函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | eval() 函数用来执行一个字符串表达式，并返回表达式的值。 3 | 语法 4 | 以下是 eval() 方法的语法: 5 | eval(expression[, globals[, locals]]) 6 | 参数 7 | expression -- 表达式。 8 | globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。 9 | locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。 10 | 返回值 11 | 返回表达式计算结果。 12 | ''' 13 | x=7 14 | print(eval('3*x')) #返回 21 15 | print(eval('pow(2,2)')) #返回 4 16 | print(eval('3+5')) #返回 8 17 | 18 | 19 | #eval函数还可以实现list、dict、tuple与str之间的转化 20 | 21 | #1.字符串转换成列表 22 | a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]" 23 | print(type(a)) #返回 24 | b = eval(a) 25 | print(type(b)) #返回 26 | print(b) #输出 [[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]] 27 | 28 | #2.字符串转换成字典 29 | a = "{1: 'a', 2: 'b'}" 30 | print(type(a)) #返回 31 | b = eval(a) 32 | print(type(b)) #返回 33 | print(b) #输出 {1: 'a', 2: 'b'} 34 | 35 | #3.字符串转换成元组 36 | a = "([1,2], [3,4], [5,6], [7,8], (9,0))" 37 | print(type(a)) #返回 38 | b=eval(a) 39 | print(type(b)) #返回 40 | print(b) #输出 ([1, 2], [3, 4], [5, 6], [7, 8], (9, 0)) -------------------------------------------------------------------------------- /exec函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 函数的作用： 3 | 动态执行python代码。也就是说exec可以执行复杂的python代码，而不像eval函数那样只能计算一个表达式的值。 4 | exec(source, globals=None, locals=None, /) 5 | source：必选参数，表示需要被指定的python代码。它必须是字符串或code对象。如果source是一个字符串，该字符串会先被解析为一组python语句，然后执行。如果source是一个code对象，那么它只是被简单的执行。 6 | 返回值： 7 | exec函数的返回值永远为None。 8 | 9 | eval()函数和exec()函数的区别： 10 | eval()函数只能计算单个表达式的值，而exec()函数可以动态运行代码段。 11 | eval()函数可以有返回值，而exec()函数返回值永远为None。 12 | ''' 13 | 14 | x = 10 15 | def func(): 16 | y = 20 17 | a = exec("x+y") 18 | print("a:",a) #输出 a: None 19 | b = exec("x+y",{"x":1,"y":2}) 20 | print("b:",b) #输出 b: None 21 | c = exec("x+y",{"x":1,"y":2},{"y":3,"z":4}) 22 | print("c:",c) #输出 c: None 23 | d = exec("print(x,y)") 24 | print("d:",d) #输出 d: None 25 | func() 26 | 27 | 28 | 29 | x = 10 30 | expr = """ 31 | z = 30 32 | sum = x + y + z #一大包代码 33 | print(sum) 34 | """ 35 | def func(): 36 | y = 20 37 | exec(expr) #10+20+30 输出60 38 | exec(expr,{'x':1,'y':2}) #30+1+2 输出 33 39 | exec(expr,{'x':1,'y':2},{'y':3,'z':4}) #30+1+3，x是定义全局变量1，y是局部变量 输出34 40 | 41 | func() 42 | 43 | #参考原博客 https://www.cnblogs.com/yangmingxianshen/p/7810496.html -------------------------------------------------------------------------------- /filter函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | filter() 函数是一个对于可迭代对象的过滤器，过滤掉不符合条件的元素， 3 | 返回的是一个迭代器，如果要转换为列表，可以使用 list() 来转换。 4 | 该函数接收两个参数，第一个为函数的引用或者None，第二个为可迭代对象， 5 | 可迭代对象中的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到迭代器中 6 | 下面看下fiter()的用法： 7 | ''' 8 | 9 | my_list=[1,2,'',3,4,'6',' '] 10 | new_list=list(filter(None,my_list)) 11 | print(new_list) 12 | #None 函数 过滤掉'' 而不是过滤掉空字符串 13 | 14 | def is_oushu(x): 15 | return x%2==0 16 | new_list=list(filter(is_oushu,list(range(1,11)))) 17 | print(new_list) 18 | #过滤掉不是偶数的数 19 | 20 | a=[1,2,3,4,5,6,2,2,2,] 21 | print(list(filter(lambda x:x!=2,a))) 22 | #筛选出列表里所有的不是 2 的元素 -------------------------------------------------------------------------------- /flaot函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | float() 函数用于将整数和字符串转换成浮点数。 4 | 语法 5 | float()方法语法： 6 | class float([x]) 7 | 参数 8 | x -- 整数或字符串 9 | 返回值 10 | 返回浮点数。 11 | ''' 12 | print(float(1)) #输出 1.0 13 | print(float(112.0)) #输出 112.0 14 | print(float('123')) #输出 123.0 15 | print(float(True)) #输出 1.0 16 | print(float(False)) #输出 0.0 17 | 18 | #print(float('a')) 19 | #报错 ValueError: could not convert string to float: 'a' 20 | 21 | #可以参考博客 https://blog.csdn.net/TCatTime/article/details/82932818 -------------------------------------------------------------------------------- /format函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 自python2.6开始，新增了一种格式化字符串的函数str.format()，此函数可以快速处理各种字符串。 3 | 语法 4 | 它通过{}和:来代替%。 5 | 请看下面的示例，基本上总结了format函数在python的中所有用法 6 | ''' 7 | #通过位置 8 | print ('{0},{1}'.format('chuhao',20)) 9 | #chuhao,20 10 | print ('{},{}'.format('chuhao',20)) 11 | #chuhao,20 12 | print ('{1},{0},{1}'.format('chuhao',20)) 13 | #20,chuhao,20 14 | #通过关键字参数 15 | print ('{name},{age}'.format(age=18,name='chuhao')) 16 | #chuhao,18 17 | class Person: 18 | def __init__(self,name,age): 19 | self.name = name 20 | self.age = age 21 | 22 | def __str__(self): 23 | return 'This guy is {self.name},is {self.age} old'.format(self=self) 24 | 25 | print (str(Person('chuhao',18))) #This guy is chuhao,is 18 old 26 | 27 | #通过映射 list 28 | a_list = ['chuhao',20,'china'] 29 | print ('my name is {0[0]},from {0[2]},age is {0[1]}'.format(a_list)) 30 | #my name is chuhao,from china,age is 20 31 | 32 | #通过映射 dict 33 | b_dict = {'name':'chuhao','age':20,'province':'shanxi'} 34 | print ('my name is {name}, age is {age},from {province}'.format(**b_dict)) 35 | #my name is chuhao, age is 20,from shanxi 36 | 37 | #填充与对齐 38 | print ('{:>8}'.format('189')) 39 | # 189 40 | print ('{:0>8}'.format('189')) 41 | #00000189 42 | print ('{:a>8}'.format('189')) 43 | #aaaaa189 44 | 45 | #精度与类型f 46 | #保留两位小数 47 | print ('{:.2f}'.format(321.33345)) 48 | #321.33 49 | 50 | #用来做金额的千位分隔符 51 | print ('{:,}'.format(1234567890)) 52 | #1,234,567,890 53 | 54 | #其他类型 主要就是进制了，b、d、o、x分别是二进制、十进制、八进制、十六进制。 55 | 56 | print ('{:b}'.format(18)) #二进制 10010 57 | print ('{:d}'.format(18)) #十进制 18 58 | print ('{:o}'.format(18)) #八进制 22 59 | print ('{:x}'.format(18)) #十六进制12 60 | 61 | 62 | 63 | #参考博客 https://www.cnblogs.com/gide/p/6955895.html 64 | 65 | -------------------------------------------------------------------------------- /frozenset函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。 4 | 语法 5 | frozenset() 函数语法： 6 | class frozenset([iterable]) 7 | 参数 8 | iterable -- 可迭代的对象，比如列表、字典、元组等等。 9 | 返回值 10 | 返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。 11 | ''' 12 | 13 | a=frozenset(range(10)) 14 | print(a) 15 | #输出 frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) 16 | 17 | b=frozenset('ltftyut1234') 18 | print(b) 19 | #输出 frozenset({'2', '4', 't', 'f', '1', '3', 'l', 'y', 'u'}) 20 | 21 | # 1 frozenset([iterable]) 22 | # 2 set和frozenset最本质的区别是前者是可变的，后者是不可变的。当集合对象会被改变时（例如删除，添加元素），只能使用set， 23 | # 3 一般来说使用fronzet的地方都可以使用set。 24 | # 4 参数iterable：可迭代对象。 -------------------------------------------------------------------------------- /getattr函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述： 3 | getattr()函数用于返回一个对象属性值 4 | 语法： 5 | getattr(object,name,default) 6 | 参数： 7 | object--对象 8 | name--字符串，对象属性 9 | default--默认返回值，如果不提供该参数，在没有对应属性时，将触发AttributeError。 10 | 返回值： 11 | 返回对象属性值 12 | ''' 13 | 14 | class People(): 15 | sex='男' 16 | def __init__(self,name): 17 | self.name=name 18 | def peopleinfo(self): 19 | print('欢迎%s访问'%self.name) 20 | 21 | obj=getattr(People,'sex') 22 | print(obj) #返回值 男 23 | 24 | #obj=getattr(People,'sexage') 25 | #print(obj) 26 | ''' 27 | 报错。。。 28 | Traceback (most recent call last): 29 | File "G:/pythonAI/Python_funs/getattr函数详解.py", line 24, in 30 | obj=getattr(People,'sexage') 31 | AttributeError: type object 'People' has no attribute 'sexage' 32 | ''' 33 | 34 | obj=getattr(People,'sexage',None) 35 | print(obj) #返回值 None -------------------------------------------------------------------------------- /globals函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | globals() 函数会以字典类型返回当前位置的全部全局变量。 4 | 语法 5 | globals() 函数语法： 6 | globals() 7 | 参数 8 | 无 9 | 返回值 10 | 返回全局变量的字典 11 | ''' 12 | a='ltftyut1234' 13 | print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。 14 | # {'__name__': '__main__', '__doc__': '\n描述\nglobals() 函数会以字典类型返回当前位置的全部全局变量。\n语法\nglobals() 函数语法：\nglobals()\n参数\n无\n返回值\n返回全局变量的字典\n', '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001C5A50FB4E0>, '__spec__': None, '__annotations__': {}, '__builtins__': , '__file__': 'G:/pythonAI/Python_funs/globals函数详解.py', '__cached__': None, 'a': 'ltftyut1234'} 15 | 16 | 17 | 18 | def zero_promo(): 19 | return 0 20 | 21 | def one_promo(): 22 | return 1 23 | 24 | def two_promo(): 25 | return 2 26 | 27 | def hello(): 28 | print("Hello") 29 | 30 | if __name__ == '__main__': 31 | promos = [name for name in globals()if name.endswith("_promo")] 32 | print(promos) #输出 ['zero_promo', 'one_promo', 'two_promo'] 33 | 34 | promos = [globals()[name] for name in globals() if name.endswith("_promo")] 35 | print(promos[0]()) #输出 0 调用了第一个函数 36 | 37 | #参考博客 https://www.jianshu.com/p/a9f583d8cbaa 38 | 39 | -------------------------------------------------------------------------------- /hasattr函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | hasattr()函数用于判断是否包含对应的属性 3 | 语法： 4 | hasattr(object,name) 5 | 参数： 6 | object--对象 7 | name--字符串，属性名 8 | 返回值： 9 | 如果对象有该属性返回True，否则返回False 10 | ''' 11 | 12 | class People(): 13 | sex='男' 14 | def __init__(self,name): 15 | self.name=name 16 | def peopleinfo(self): 17 | print('欢迎%s访问'%self.name) 18 | 19 | obj=People('zhangsan') 20 | print(hasattr(People,'sex')) #输出 True 21 | print('sex'in People.__dict__) #输出 True 22 | 23 | print(hasattr(obj,'peopleinfo')) #输出 True 24 | print(People.__dict__) 25 | #输出 {'__module__': '__main__', 'sex': '男', '__init__': , 'peopleinfo': , '__dict__': , '__weakref__': , '__doc__': None} -------------------------------------------------------------------------------- /hash函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | hash() 用于获取取一个对象（字符串或者数值等）的哈希值。 4 | 语法 5 | hash 语法： 6 | hash(object) 7 | 参数说明： 8 | object -- 对象； 9 | 返回值 10 | 返回对象的哈希值。 11 | ''' 12 | 13 | print(hash('test')) #输出 -2950866779904704330 会改变的 14 | print(hash(1)) #数字 输出 1 15 | print(hash(str([1,2,3]))) # 集合 输出 -6217131644886971364 16 | print(hash(str(sorted({'1':1})))) # 字典 输出 -6233802074491902648 17 | 18 | ''' 19 | hash() 函数可以应用于数字、字符串和对象，不能直接应用于 list、set、dictionary。 20 | 在 hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关。 21 | ''' 22 | class Test: 23 | def __init__(self, i): 24 | self.i = i 25 | for i in range(10): 26 | t = Test(1) 27 | print(hash(t), id(t)) 28 | 29 | ''' 30 | -9223371889060894604 2364702099272 31 | 147793883435 2364702134960 32 | -9223371889060894604 2364702099272 33 | 147793883435 2364702134960 34 | -9223371889060894604 2364702099272 35 | 147793883435 2364702134960 36 | -9223371889060894604 2364702099272 37 | 147793883435 2364702134960 38 | -9223371889060894604 2364702099272 39 | 147793883435 2364702134960 40 | ''' 41 | 42 | ''' 43 | hash() 函数的用途 44 | hash() 函数的对象字符不管有多长，返回的 hash 值都是固定长度的， 45 | 也用于校验程序在传输过程中是否被第三方（木马）修改， 46 | 如果程序（字符）在传输过程中被修改hash值即发生变化， 47 | 如果没有被修改，则 hash 值和原始的 hash 值吻合， 48 | 只要验证 hash 值是否匹配即可验证程序是否带木马（病毒）。 49 | ''' 50 | 51 | name1='正常程序代码' 52 | name2='正常程序代码带病毒' 53 | print(hash(name1)) # 2403189487915500087 54 | print(hash(name2)) # -8751655075885266653 -------------------------------------------------------------------------------- /hex函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | hex() 函数将一个整数转换成十六进制字符串。 4 | 语法 5 | hex 语法： 6 | hex(x) 7 | 参数说明： 8 | x -- 整数。 9 | 返回值 10 | 返回十六进制字符串。 11 | ''' 12 | print(hex(12)) #输出12的八进制 0xc 13 | print(hex(-120)) #输出-12的二进制 -0x78 14 | print(type(hex(12))) #输出oct(12) 的类型 所以不能直接计算 15 | 16 | print(int(hex(10),base=16)+int(hex(15),base=16)) #输出 25 17 | 18 | #base 参数不可为空 为空默认参数为10进制 会报错 ValueError: invalid literal for int() with base 10: '0b1010' 19 | 20 | #当然了，参数不仅可以接受十进制整数，八进制、十六进制也是可以的，只要是int型数据就合法。 21 | 22 | print(hex(0b10010)) #输出0x12 23 | print(hex(0o1357)) #输出0x2ef 24 | print(hex(0x2d9)) #输出0x2d9 -------------------------------------------------------------------------------- /id函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | id() 函数用于获取对象的内存地址。 3 | 语法 4 | id 语法： 5 | id([object]) 6 | 参数说明： 7 | object -- 对象。 8 | 返回值 9 | 返回对象的内存地址。 10 | ''' 11 | str='zhangsan' 12 | print(id(str)) #输出 1556579882544 动态分配 id 每一次会改变 13 | 14 | b=1 15 | print(id(b)) #输出 1597205568 16 | 17 | ''' 18 | id方法的返回值就是对象的内存地址。 19 | 20 | python2中会为每个出现的对象分配内存，哪怕他们的值完全相等（注意是相等不是相同）。 21 | 如执行a=2.0，b=2.0这两个语句时会先后为2.0这个Float类型对象分配内存， 22 | 然后将a与b分别指向这两个对象。所以a与b指向的不是同一对象 23 | 24 | python3中 值相等的变量 内存一样 如下图所示 25 | ''' 26 | 27 | a=10.21 28 | b=10.21 29 | print(id(a)) #输出2036826247912 30 | print(id(b)) #输出2036826247912 31 | print(a is b) #输出 True 32 | print(a == b) #输出 True 33 | 34 | ''' 35 | id 函数 涉及到 浅拷贝和深拷贝的相关知识 36 | 37 | 深copy和浅copy 38 | 深copy新建一个对象重新分配内存地址，复制对象内容。 39 | 40 | 浅copy不重新分配内存地址，内容指向之前的内存地址。 41 | 浅copy如果对象中有引用其他的对象，如果对这个子对象进行修改，子对象的内容就会发生更改。 42 | ''' 43 | 44 | import copy 45 | 46 | #这里有子对象 47 | numbers=['1','2','3',['4','5']] 48 | #浅copy 49 | num1=copy.copy(numbers) 50 | #深copy 51 | num2=copy.deepcopy(numbers) 52 | 53 | #直接对对象内容进行修改 54 | num1.append('6') 55 | 56 | #这里可以看到内容地址发生了偏移，增加了偏移‘6’的地址 57 | print('numbers:',numbers) 58 | print('numbers memory address:',id(numbers)) 59 | print('numbers[3] memory address',id(numbers[3])) 60 | print('num1:',num1) 61 | print('num1 memory address:',id(num1)) 62 | print('num1[3] memory address',id(num1[3])) 63 | 64 | 65 | num1[3].append('6') 66 | 67 | print('numbers:',numbers) 68 | print('num1:',num1) 69 | print('num2',num2) 70 | ''' 71 | 72 | 输出： 73 | numbers: ['1', '2', '3', ['4', '5']] 74 | numbers memory address: 1556526434888 75 | numbers memory address 1556526434952 76 | num1: ['1', '2', '3', ['4', '5'], '6'] 77 | num1 memory address: 1556526454728 78 | num1[3] memory address 1556526434952 79 | numbers: ['1', '2', '3', ['4', '5', '6']] 80 | num1: ['1', '2', '3', ['4', '5', '6'], '6'] 81 | num2 ['1', '2', '3', ['4', '5']] 82 | ''' 83 | 84 | #参考博客 https://www.cnblogs.com/dplearning/p/5998112.html 85 | #参考博客 https://www.cnblogs.com/JackFu/p/8014762.html -------------------------------------------------------------------------------- /input函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。 3 | 注意：在 Python3.x 中 raw_input() 和 input() 进行了整合， 4 | 去除了 raw_input( )，仅保留了input( )函数，其接收任意任性输入， 5 | 将所有输入默认为字符串处理，并返回字符串类型。 6 | 函数语法 7 | input([prompt]) 8 | 参数说明： 9 | prompt: 提示信息 10 | ''' 11 | 12 | a=input('请输入一个数:') #输入 10 13 | print(a) #输出 10 14 | print(type(a)) #输出 15 | #b=a+10 #报错 TypeError: must be str, not int 16 | b=int(a)+10 #转换成整型 17 | print(b) #输出 20 18 | 19 | a=input('请输入一个字符串:') #输入 ltf1234 20 | print(a) #输出 字符串ltf1234 可以使用字符串对应的方法 21 | print(a.split('1')) #输出 ['ltf', '234'] split 切割字符串 直接输出列表 -------------------------------------------------------------------------------- /int函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | int([x[,radix]]) 3 | 如果参数是字符串，那么它可能包含符号和小数点。参数radix表示转换的基数（默认是10进制）。 4 | 它可以是[2,36]范围内的值，或者0。如果是0，系统将根据字符串内容来解析。 5 | 如果提供了参数radix，但参数x并不是一个字符串，将抛出TypeError异常； 6 | 否则，参数x必须是数值（普通整数，长整数，浮点数）。通过舍去小数点来转换浮点数。 7 | 如果超出了普通整数的表示范围，一个长整数被返回。 8 | 如果没有提供参数，函数返回0。 9 | 10 | int(x, [base]) 11 | 作用： 12 | 将一个数字或base类型的字符串转换成整数。 13 | int(x=0) 14 | int(x, base=10)，base缺省值为10，也就是说不指定base的值时，函数将x按十进制处理。 15 | 注： 16 | 1. x 可以是数字或字符串，但是base被赋值后 x 只能是字符串 17 | 2. x 作为字符串时必须是 base 类型，也就是说 x 变成数字时必须能用 base 进制表示 18 | ''' 19 | 20 | #1.x是数字 21 | print(int(2.1)) #输出 2 22 | print(int(2e3)) #输出 2000 23 | #print(int(1000,2)) #出错，base 被赋值后函数只接收字符串 24 | #报错 TypeError: int() can't convert non-string with explicit base 25 | 26 | #2.x是字符串 27 | print(int('abc12',16)) #输出 703506 28 | #print(int('tuifyg',16)) #出错 tuifyg 超过0-9 abcdef 超出16进制 29 | #报错 ValueError: invalid literal for int() with base 16: 'tuifyg' 30 | 31 | #3. base 可取值范围是 2~36，囊括了所有的英文字母(不区分大小写)， 32 | # 十六进制中F表示15，那么G将在二十进制中表示16，依此类推....Z在三十六进制中表示35 33 | #print(int('FZ',16)) # 出错，FZ不能用十六进制表示 34 | #报错 ValueError: invalid literal for int() with base 16: 'FZ' 35 | print(int('FZ',36)) # 575 36 | 37 | #4.字符串 0x 可以出现在十六进制中，视作十六进制的符号， 38 | # 同理 0b 可以出现在二进制中，除此之外视作数字 0 和字母 x 39 | print(int('0x10', 16)) # 16，0x是十六进制的符号 40 | #print(int('0x10', 17)) # 出错，'0x10'中的 x 被视作英文字母 x 41 | print(int('0x10', 36)) # 42804，36进制包含字母 x 42 | 43 | 44 | #参考博客 https://www.cnblogs.com/guyuyuan/p/6827987.html -------------------------------------------------------------------------------- /isinstance函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。 3 | isinstance() 与 type() 区别： 4 | type() 不会认为子类是一种父类类型，不考虑继承关系。 5 | isinstance() 会认为子类是一种父类类型，考虑继承关系。 6 | 如果要判断两个类型是否相同推荐使用 isinstance()。 7 | 8 | 语法 9 | 以下是 isinstance() 方法的语法: 10 | isinstance(object, classinfo) 11 | 参数 12 | object -- 实例对象。 13 | classinfo -- 可以是直接或间接类名、基本类型或者有它们组成的元组。 14 | 返回值 15 | 如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。。 16 | ''' 17 | 18 | a=2 19 | print(isinstance(a,int)) #返回 True 20 | print(isinstance(a,str)) #返回 Fasle 21 | print(isinstance(a,(str,int,list))) #返回 True 是元组中的一个类型 就行 22 | 23 | 24 | class A: 25 | pass 26 | 27 | class B(A): 28 | pass 29 | 30 | print(isinstance(A(), A) ) # returns True 31 | print(type(A()) == A ) # returns True 32 | print(isinstance(B(), A)) # returns True 33 | print(type(B()) == A) # returns False 34 | 35 | -------------------------------------------------------------------------------- /issubclass函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。 4 | 语法 5 | 以下是 issubclass() 方法的语法: 6 | issubclass(class, classinfo) 7 | 参数 8 | class -- 类。 9 | classinfo -- 类。 10 | 返回值 11 | 如果 class 是 classinfo 的子类返回 True，否则返回 False。 12 | ''' 13 | 14 | 15 | class A: 16 | pass 17 | 18 | class B(A): 19 | pass 20 | 21 | class C(A): 22 | pass 23 | 24 | print(issubclass(B, A)) # 返回 True 25 | print(issubclass(C, A)) # 返回 True 26 | print(issubclass(C, B)) # 返回 False 27 | 28 | #2.class参数是classinfo的子类，并且classinfo是元组 29 | print(issubclass(C, (A, object))) #返回 True 30 | print(issubclass(C, (A, int, object))) #返回 True 31 | print(issubclass(C, (int, str))) #返回 False 32 | print(issubclass(C, (int, str, type))) #返回 False 33 | 34 | #print(issubclass(C, (1, A))) 35 | #报错 TypeError: issubclass() arg 2 must be a class or tuple of classes 36 | 37 | #参考简书 https://www.jianshu.com/p/4c425bbdd773 -------------------------------------------------------------------------------- /iter函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | iter() 函数用来生成迭代器。 4 | 语法 5 | 以下是 iter() 方法的语法: 6 | iter(object[, sentinel]) 7 | 参数 8 | object -- 支持迭代的集合对象。 9 | sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。 10 | 打开模式 11 | 返回值 12 | 迭代器对象。 13 | 14 | 1 iter(o[, sentinel]) 15 | 2 返回一个iterator对象。该函数对于第一个参数的解析依赖于第二个参数。 16 | 3 如果没有提供第二个参数，参数o必须是一个集合对象，支持遍历功能（__iter__()方法）或支持序列功能（__getitem__()方法）， 17 | 4 参数为整数，从零开始。如果不支持这两种功能，将处罚TypeError异常。 18 | 5 如果提供了第二个参数，参数o必须是一个可调用对象。在这种情况下创建一个iterator对象，每次调用iterator的next()方法来无 19 | 6 参数的调用o，如果返回值等于参数sentinel，触发StopIteration异常，否则将返回该值。 20 | ''' 21 | 22 | lst = [1,2,3,4,5,6,7] 23 | for i in iter(lst): 24 | print(i) #输出1,2,3,4,5,6,7 25 | 26 | 27 | class counter: 28 | def __init__(self, _start, _end): 29 | self.start = _start 30 | self.end = _end 31 | def get_next(self): 32 | s = self.start 33 | if(self.start < self.end): 34 | self.start += 1 35 | else: 36 | raise StopIteration 37 | return s 38 | 39 | c = counter(1, 5) 40 | iterator = iter(c.get_next, 3) 41 | print(type(iterator)) #返回 42 | for i in iterator: 43 | print(i) #输出 1 2 44 | 45 | 46 | #参考博客 https://www.cnblogs.com/yitouniu/p/5243136.html -------------------------------------------------------------------------------- /lambda函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 匿名函数lambda：是指一类无需定义标识符（函数名）的函数或子程序。 3 | lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值。 4 | 5 | 要点： 6 | 1，lambda 函数不能包含命令， 7 | 8 | 2，包含的表达式不能超过一个。 9 | 10 | 说明：一定非要使用lambda函数；任何能够使用它们的地方，都可以定义一个单独的普通函数来进行替换。 11 | 我将它们用在需要封装特殊的、非重用代码上，避免令我的代码充斥着大量单行函数。 12 | 13 | lambda匿名函数的格式：冒号前是参数，可以有多个，用逗号隔开，冒号右边的为表达式。 14 | 其实lambda返回值是一个函数的地址，也就是函数对象。 15 | ''' 16 | def sum(x,y): 17 | return x+y 18 | print(sum(4,6)) 19 | 20 | f=lambda x,y:x+y 21 | print(f(4,6)) 22 | #这俩个例子的效果是一样的，都是返回x+y 23 | 24 | a=lambda x:x*x 25 | print(a(4)) #传入一个参数的lambda函数 返回x*x 26 | 27 | b=lambda x,y,z:x+y*z 28 | print(b(1,2,3)) #返回x+y*z 即1+2*3=7 29 | 30 | #2.方法结合使用 31 | from functools import reduce 32 | foo=[2, 18, 9, 22, 17, 24, 8, 12, 27] 33 | print(list(filter(lambda x:x%3==0,foo))) #筛选x%3==0 的元素 34 | print(list(map(lambda x:x*2+10,foo))) #遍历foo 每个元素乘2+10 再输出 35 | print(reduce(lambda x,y:x+y,foo)) #返回每个元素相加的和 -------------------------------------------------------------------------------- /len函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | Python len() 方法返回对象（字符、列表、元组等）长度或项目个数。 4 | 语法 5 | len()方法语法： 6 | len( s ) 7 | 参数 8 | s -- 对象。 9 | 返回值 10 | 返回对象长度。 11 | ''' 12 | str1='ltf1234' 13 | print(len(str1)) #输出 7 14 | 15 | list1=[1,2,3,4,5,6,7,8] 16 | print(len(list1)) #输出 8 17 | 18 | for i in range(len(list1)): 19 | print(i) #依次输出1-8 20 | 21 | dict = {'num':777,'name':"anne"} 22 | print(len(dict)) #输出 2 23 | 24 | #参考博客 https://www.cnblogs.com/101718qiong/p/7542193.html -------------------------------------------------------------------------------- /list函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | list()　　列表构造函数 3 | 4 | 1 list([iterable]) 5 | 2 list的构造函数。参数iterable是可选的，它可以是序列，支持编译的容器对象，或iterator对象。 6 | 3 该函数创建一个元素值，顺序与参数iterable一致的列表。如果参数iterable是一个列表，将创建 7 | 4 列表的一个拷贝并返回，就像语句iterables[:]。 8 | ''' 9 | 10 | list=[1,2,3,4,5,6,7,8,9] #构建列表 11 | print(list) #输出 [1,2,3,4,5,6,7,8,9] 12 | 13 | list.append(10) #列表追加 10 14 | print(list) #输出 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 15 | 16 | list.insert(2,18) #在列表索引为2 的位置 插入 18 其余的后移 17 | print(list) #输出 [1, 2, 18, 3, 4, 5, 6, 7, 8, 9, 10] 18 | 19 | print(list.count(1)) #输出 列表里1 的数量 20 | 21 | list2=[-1,-2,-3] 22 | list.extend(list2) #列表追加列表 23 | print(list) #输出 [1, 2, 18, 3, 4, 5, 6, 7, 8, 9, 10, -1, -2, -3] 24 | 25 | list.remove(1) #删除列表里的第一个1 26 | print(list) #输出 [2, 18, 3, 4, 5, 6, 7, 8, 9, 10, -1, -2, -3] 27 | 28 | list.sort() #列表排序 29 | print(list) #输出 [-3, -2, -1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 18] 30 | 31 | list.reverse() #列表反转 32 | print(list) #输出 [18, 10, 9, 8, 7, 6, 5, 4, 3, 2, -1, -2, -3] 33 | 34 | print(max(list)) #输出列表最大值 18 35 | print(min(list)) #输出列表最小值 -3 36 | 37 | list3=[1,2,3,'q','a','s'] 38 | #print(max(list3)) #报错 >' not supported between instances of 'str' and 'int' 39 | #print(min(list3)) #报错 >' not supported between instances of 'str' and 'int' 40 | -------------------------------------------------------------------------------- /locals函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | locals() 函数会以字典类型返回当前位置的全部局部变量。 3 | 对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。 4 | 语法 5 | locals() 函数语法： 6 | locals() 7 | 参数 8 | 无 9 | 返回值 10 | 返回字典类型的局部变量 11 | 12 | 1 不要修改locals()返回的字典中的内容；改变可能不会影响解析器对局部变量的使用。 13 | 2 在函数体内调用locals()，返回的是自由变量。修改自由变量不会影响解析器对变量的使用。 14 | 3 不能在类区域内返回自由变量。 15 | ''' 16 | 17 | def test_py(arg): 18 | z=1 19 | print(locals()) 20 | test_py(6) #输出 {'z': 1, 'arg': 6} 21 | 22 | 23 | def foo(arg, a): 24 | x = 100 25 | y = 'hello python!' 26 | for i in range(10): 27 | j = 1 28 | k = i 29 | print(locals()) 30 | foo(1, 2) #输出 {'k': 9, 'j': 1, 'i': 9, 'y': 'hello python!', 'x': 100, 'a': 2, 'arg': 1} 31 | 32 | #参考博客 https://blog.csdn.net/sxingming/article/details/52061630 33 | 34 | 35 | -------------------------------------------------------------------------------- /map函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | map()函数 3 | map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list， 4 | 并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。 5 | 6 | 例如，对于list [1, 2, 3, 4, 5, 6, 7, 8, 9] 7 | 如果希望把list的每个元素都作平方，就可以用map()函数： 8 | 9 | 因此，我们只需要传入函数f(x)=x*x，就可以利用map()函数完成这个计算： 10 | ''' 11 | list=[1,2,3,4,5,6,7,8,9] 12 | def f(x): 13 | return x*x 14 | list1=map(f,list) 15 | print(list1) 16 | for i in list1: 17 | print(i) 18 | 19 | ''' 20 | 注意：map()函数不改变原有的 list，而是返回一个新的 list。 21 | 22 | 利用map()函数，可以把一个 list 转换为另一个 list，只需要传入转换函数。 23 | 24 | 由于list包含的元素可以是任何类型，因此，map() 不仅仅可以处理只包含数值的 list， 25 | 事实上它可以处理包含任意类型的 list，只要传入的函数f可以处理这种数据类型。 26 | 27 | 任务 28 | 假设用户输入的英文名字不规范，没有按照首字母大写，后续字母小写的规则， 29 | 请利用map()函数，把一个list（包含若干不规范的英文名字）变成一个包含规范英文名字的 30 | ''' 31 | def format_name(s): 32 | s1=s[0:1].upper()+s[1:].lower() 33 | return s1 34 | names=['adam', 'LISA', 'barT'] 35 | print (map(format_name, names)) #python2 这样写可以直接输出列表 36 | for i in map(format_name,names): 37 | print(i) #python3 得这样写才可以 -------------------------------------------------------------------------------- /max函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | max() 方法返回给定参数的最大值，参数可以为序列。 4 | 5 | 语法 6 | 以下是 max() 方法的语法: 7 | max( x, y, z, .... ) 8 | 9 | 参数 10 | x -- 数值表达式。 11 | y -- 数值表达式。 12 | z -- 数值表达式。 13 | 14 | 返回值 15 | 返回给定参数的最大值。 16 | ''' 17 | 18 | print ("max(80, 100, 1000) : ", max(80, 100, 1000)) 19 | print ("max(-20, 100, 400) : ", max(-20, 100, 400)) 20 | print ("max(-80, -20, -10) : ", max(-80, -20, -10)) 21 | print ("max(0, 100, -400) : ", max(0, 100, -400)) 22 | 23 | ''' 24 | 输出结果： 25 | max(80, 100, 1000) : 1000 26 | max(-20, 100, 400) : 400 27 | max(-80, -20, -10) : -10 28 | max(0, 100, -400) : 100 29 | ''' 30 | 31 | #1.传入的多个参数的最大值 32 | print(max(1,2,3,4)) #输出 4 33 | 34 | #2.传入可迭代对象时，取其元素最大值 35 | s='12345' 36 | print(max(s)) #输出 5 37 | 38 | #3.传入命名参数key，其为一个函数，用来指定取最大值的方法 39 | 40 | s = [ 41 | {'name': 'sumcet', 'age': 18}, 42 | {'name': 'bbu', 'age': 11} 43 | ] 44 | a = max(s, key=lambda x: x['age']) 45 | print(a) #输出 {'name': 'sumcet', 'age': 18} 46 | -------------------------------------------------------------------------------- /min函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | min() 方法返回给定参数的最小值，参数可以为序列。 4 | 5 | 语法 6 | 以下是 min() 方法的语法: 7 | min( x, y, z, .... ) 8 | 9 | 参数 10 | x -- 数值表达式。 11 | y -- 数值表达式。 12 | z -- 数值表达式。 13 | 14 | 返回值 15 | 返回给定参数的最小值。 16 | ''' 17 | 18 | print ("min(80, 100, 1000) : ", min(80, 100, 1000)) 19 | print ("min(-20, 100, 400) : ", min(-20, 100, 400)) 20 | print ("min(-80, -20, -10) : ", min(-80, -20, -10)) 21 | print ("min(0, 100, -400) : ", min(0, 100, -400)) 22 | 23 | ''' 24 | 输出结果 25 | min(80, 100, 1000) : 80 26 | min(-20, 100, 400) : -20 27 | min(-80, -20, -10) : -80 28 | min(0, 100, -400) : -400 29 | ''' 30 | 31 | #1.传入的多个参数的最小值 32 | print(min(1,2,3,4)) #输出 1 33 | 34 | #2.传入可迭代对象时，取其元素最小值 35 | s='12345' 36 | print(min(s)) #输出 1 37 | 38 | #3.传入命名参数key，其为一个函数，用来指定取最小值的方法 39 | 40 | s = [ 41 | {'name': 'sumcet', 'age': 18}, 42 | {'name': 'bbu', 'age': 11} 43 | ] 44 | a = min(s, key=lambda x: x['age']) 45 | print(a) #输出 {'name': 'bbu', 'age': 11} -------------------------------------------------------------------------------- /next函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | next() 返回迭代器的下一个项目。 4 | 语法 5 | next 语法： 6 | next(iterator[, default]) 7 | 参数说明： 8 | iterator -- 可迭代对象 9 | default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。 10 | 返回值 11 | 返回对象帮助信息。 12 | ''' 13 | 14 | # 首先获得Iterator对象: 15 | it = iter([1, 2, 3, 4, 5]) 16 | # 循环: 17 | while True: 18 | try: 19 | # 获得下一个值: 20 | x = next(it) 21 | print(x) 22 | except StopIteration: 23 | # 遇到StopIteration就退出循环 24 | break 25 | 26 | a=iter('abcde') 27 | print(next(a)) #输出 a 28 | print(next(a)) #输出 b 29 | print(next(a)) #输出 c 30 | print(next(a)) #输出 d 31 | print(next(a)) #输出 e 32 | #print(next(a)) #报错 StopIteration 33 | 34 | #函数可以接收一个可选的default参数，传入default参数后， 35 | # 如果可迭代对象还有元素没有返回，则依次返回其元素值，如果所有元素已经返回， 36 | # 则返回default指定的默认值而不抛出StopIteration 异常。 37 | 38 | print(next(a,'e')) #这次不报错了 返回 e 即default参数 39 | 40 | #参考博客 http://www.cnblogs.com/sesshoumaru/p/6037922.html 41 | -------------------------------------------------------------------------------- /oct函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | oct() 函数将一个整数转换成八进制字符串。 4 | 语法 5 | oct 语法： 6 | oct(x) 7 | 参数说明： 8 | x -- 整数。 9 | 返回值 10 | 返回八进制字符串。 11 | ''' 12 | 13 | print(oct(12)) #输出12的八进制 0o14 14 | print(oct(-120)) #输出-12的二进制 -0o170 15 | print(type(oct(12))) #输出oct(12) 的类型 所以不能直接计算 16 | 17 | print(int(oct(10),base=8)+int(oct(15),base=8)) #输出 25 18 | 19 | #base 参数不可为空 为空默认参数为10进制 会报错 ValueError: invalid literal for int() with base 10: '0b1010' 20 | 21 | #当然了，参数不仅可以接受十进制整数，八进制、十六进制也是可以的，只要是int型数据就合法。 22 | 23 | print(oct(0b10010)) #输出0o22 24 | print(oct(0o1357)) #输出0o1357 25 | print(oct(0x2d9)) #输出0o1331 -------------------------------------------------------------------------------- /open函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | python open() 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。 3 | 更多文件操作可参考：Python 文件I/O。 4 | 函数语法 5 | open(name[, mode[, buffering]]) 6 | 参数说明： 7 | name : 一个包含了你要访问的文件名称的字符串值。 8 | mode : mode 决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。 9 | buffering : 如果 buffering 的值被设为 0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。如果将 buffering 的值设为大于 1 的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。 10 | 不同模式打开文件的完全列表： 11 | 模式 12 | 描述 13 | r 14 | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 15 | rb 16 | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。 17 | r+ 18 | 打开一个文件用于读写。文件指针将会放在文件的开头。 19 | rb+ 20 | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。 21 | w 22 | 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 23 | wb 24 | 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 25 | w+ 26 | 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 27 | wb+ 28 | 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 29 | a 30 | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 31 | ab 32 | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 33 | a+ 34 | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 35 | ab+ 36 | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 37 | file 对象方法 38 | file.read([size])：size 未指定则返回整个文件，如果文件大小 >2 倍内存则有问题，f.read()读到文件尾时返回""(空字串)。 39 | file.readline()：返回一行。 40 | file.readlines([size]) ：返回包含size行的列表, size 未指定则返回全部行。 41 | for line in f: print line ：通过迭代器访问。 42 | f.write("hello\n")：如果要写入字符串以外的数据,先将他转换为字符串。 43 | f.tell()：返回一个整数,表示当前文件指针的位置(就是到文件头的比特数)。 44 | f.seek(偏移量,[起始位置])：用来移动文件指针。 45 | 偏移量: 单位为比特，可正可负 46 | 起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾 47 | f.close() 关闭文件 48 | 49 | 50 | open(filename [, mode [, bufsize]]) 51 | 打开一个文件，返回一个file对象。 如果文件无法打开，将处罚IOError异常。 52 | 应该使用open()来代替直接使用file类型的构造函数打开文件。 53 | 参数filename表示将要被打开的文件的路径字符串； 54 | 参数mode表示打开的模式，最常用的模式有：'r'表示读文本，'w'表示写文本文件，'a'表示在文件中追加。 55 | Mode的默认值是'r'。 56 | 当操作的是二进制文件时，只要在模式值上添加'b'。这样提高了程序的可移植性。 57 | 可选参数bufsize定义了文件缓冲区的大小。0表示不缓冲；1表示行缓冲；任何其他正数表示使用该大小的缓冲区； 58 | 负数表示使用系统默认缓冲区大小，对于tty设备它往往是行缓冲，而对于其他文件往往完全缓冲。如果参数值被省却。 59 | 使用系统默认值。 60 | ''' 61 | 62 | f=open('1.txt','r',encoding='utf-8') 63 | print(f.read()) 64 | ''' 65 | 输出... 66 | ltf 67 | zhongguo 68 | shanxi 69 | yuncheng 70 | 男 71 | 20 72 | ''' 73 | 74 | #参考博客 https://www.cnblogs.com/Devilf/p/8006663.html 75 | 76 | -------------------------------------------------------------------------------- /ord函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。 4 | 语法 5 | 以下是 ord() 方法的语法: 6 | ord(c) 7 | 参数 8 | c -- 字符。 9 | 返回值 10 | 返回值是对应的十进制整数。 11 | ''' 12 | 13 | print(ord('a')) #输出97 14 | print(ord('b')) #输出98 15 | print(ord('c')) #输出99 16 | 17 | print(ord(']')) #输出93 18 | print(ord('8')) #输出56 19 | 20 | #其实要是有一张表就好了 哈哈哈哈 21 | -------------------------------------------------------------------------------- /pow函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | pow() 方法返回 xy（x的y次方） 的值。 4 | 5 | 语法 6 | 以下是 math 模块 pow() 方法的语法: 7 | import math 8 | 9 | math.pow( x, y ) 10 | 内置的 pow() 方法 11 | pow(x, y[, z]) 12 | 函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z 13 | 注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。 14 | 15 | 参数 16 | x -- 数值表达式。 17 | y -- 数值表达式。 18 | z -- 数值表达式。 19 | 20 | 返回值 21 | 返回 xy（x的y次方） 的值。 22 | ''' 23 | 24 | import math # 导入 math 模块 25 | 26 | print("math.pow(100, 2) : ", math.pow(100, 2)) 27 | # 使用内置，查看输出结果区别 28 | print("pow(100, 2) : ", pow(100, 2)) 29 | 30 | print("math.pow(100, -2) : ", math.pow(100, -2)) 31 | print("math.pow(2, 4) : ", math.pow(2, 4)) 32 | print("math.pow(3, 0) : ", math.pow(3, 0)) 33 | 34 | ''' 35 | 输出结果... 36 | math.pow(100, 2) : 10000.0 37 | pow(100, 2) : 10000 38 | math.pow(100, -2) : 0.0001 39 | math.pow(2, 4) : 16.0 40 | math.pow(3, 0) : 1.0 41 | ''' -------------------------------------------------------------------------------- /property函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | property() 函数的作用是在新式类中返回属性值。 4 | 语法 5 | 以下是 property() 方法的语法: 6 | class property([fget[, fset[, fdel[, doc]]]]) 7 | 参数 8 | fget -- 获取属性值的函数 9 | fset -- 设置属性值的函数 10 | fdel -- 删除属性值函数 11 | doc -- 属性描述信息 12 | 返回值 13 | 返回新式类属性 14 | ''' 15 | 16 | 17 | class C(object): 18 | def __init__(self): 19 | self._x = None 20 | def getx(self): 21 | return self._x 22 | def setx(self, value): 23 | self._x = value 24 | def delx(self): 25 | del self._x 26 | x = property(getx, setx, delx, "I'm the 'x' property.") 27 | 28 | 29 | class Parrot(object): 30 | def __init__(self): 31 | self._voltage = 100000 32 | #装饰器写法 33 | @property 34 | def voltage(self): 35 | """Get the current voltage.""" 36 | return self._voltage 37 | 38 | 39 | class D(object): 40 | def __init__(self): 41 | self._x = None 42 | 43 | @property 44 | def x(self): 45 | """I'm the 'x' property.""" 46 | return self._x 47 | 48 | @x.setter 49 | def x(self, value): 50 | self._x = value 51 | 52 | @x.deleter 53 | def x(self): 54 | del self._x -------------------------------------------------------------------------------- /range函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | python range() 函数可创建一个整数列表，一般用在 for 循环中。 3 | 函数语法 4 | range(start, stop[, step]) 5 | 参数说明： 6 | start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）; 7 | stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5 8 | step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1) 9 | 10 | ''' 11 | 12 | for i in range(10): 13 | print(i) #输出 从0-9 14 | 15 | for i in range(0,11,2): 16 | print(i) #输出 0,2,4,6,8,10 17 | 18 | for i in range(0,-10,-3): 19 | print(i) #输出 0,-3,-6,-9 20 | 21 | list=[] 22 | for i in range(5,-5,-1): 23 | list.append(i) 24 | print(list) #输出 [5, 4, 3, 2, 1, 0, -1, -2, -3, -4] 25 | 26 | for i in 'ahfgohiauf': 27 | print(i) #依次输出字符 28 | 29 | #参考博客 https://www.cnblogs.com/101718qiong/p/7542193.html 30 | 31 | -------------------------------------------------------------------------------- /reduce函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 在python3中如果使用reduce需要先导入 3 | 4 | from functools import reduce 5 | 6 | reduce函数，reduce函数会对参数序列中元素进行累积。 7 | 8 | reduce函数的定义： 9 | reduce(function, sequence [, initial] ) -> value 10 | function参数是一个有两个参数的函数，reduce依次从sequence中取一个元素， 11 | 和上一次调用function的结果做参数再次调用function。 12 | 第一次调用function时，如果提供initial参数， 13 | 会以sequence中的第一个元素和initial作为参数调用function， 14 | 否则会以序列sequence中的前两个元素做参数调用function。 15 | ''' 16 | 17 | from functools import reduce 18 | lst=[1,2,3,4,5,6] 19 | def f(x,y): 20 | return x+y 21 | print(reduce(f,lst)) 22 | 23 | ''' 24 | 过程1+2+3+4+5+6=21 25 | ''' 26 | 27 | print(reduce(lambda x,y:x*y,lst)) 28 | # 运行过程为1*2*3*4*5*6=720 29 | 30 | #来个稍微复杂的 31 | print(reduce(lambda x,y:x*y+1,lst)) 32 | 33 | ''' 34 | 运算步骤：1*2+1=3 35 | 3*3+1=10 36 | 10*4+1=41 37 | 41*5+1=206 38 | 206*6+1=1237 39 | ''' 40 | 41 | #再说说有初始化值的情况, 这个时候就不是取列表的前两项, 而是取初始值为第一个, 42 | # 序列的第一个元素为第二个元素,开始进行lambda函数的应用计算. 43 | print(reduce(lambda x,y:x+y,lst,5)) 44 | 45 | ''' 46 | 计算步骤：5+1=6 47 | 6+2=8 48 | 8+3=11 49 | 11+4=15 50 | 15+5=20 51 | 20+6=26 52 | ''' 53 | -------------------------------------------------------------------------------- /repr函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | repr() 函数将对象转化为供解释器读取的形式。 4 | 语法 5 | 以下是 repr() 方法的语法: 6 | repr(object) 7 | 参数 8 | object -- 对象。 9 | 返回值 10 | 返回一个对象的 string 格式。 11 | ''' 12 | 13 | s='qwerasdf' 14 | print(s) #输出 qwerasdf 15 | print(repr(s)) #输出 'qwerasdf' 16 | 17 | dict={'a':1,'b':2} 18 | print(dict) #输出 {'a': 1, 'b': 2} 19 | print(repr(dict)) #输出 {'a': 1, 'b': 2} 没改变么 20 | 21 | print(repr([0,1,2,3,4])) #输出 [0, 1, 2, 3, 4] 22 | print(repr('hello')) #输出 'hello' 23 | 24 | print(str(1.0/7.0)) #输出 0.14285714285714285 25 | print(repr(1.0/7.0)) #输出 0.14285714285714285 -------------------------------------------------------------------------------- /reversed函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | reversed 函数返回一个反转的迭代器。 4 | 5 | 语法 6 | 以下是 reversed 的语法: 7 | reversed(seq) 8 | 参数 9 | seq -- 要转换的序列，可以是 tuple, string, list 或 range。 10 | 返回值 11 | 返回一个反转的迭代器。 12 | 13 | 1 reversed(seq) 14 | 2 返回一个逆序的iterator对象。参数seq必须是一个包含__reversed__()方法的对象或支持序列操作(__len__()和__getitem__()) 15 | 3 该函数是2.4中新增的 16 | ''' 17 | 18 | str='wasdqwer' 19 | print(list(reversed(str))) #输出 ['r', 'e', 'w', 'q', 'd', 's', 'a', 'w'] 20 | 21 | tuple=('r', 'e', 'w', 'q', 'd', 's', 'a', 'w') 22 | print(list(reversed(tuple))) #输出 ['w', 'a', 's', 'd', 'q', 'w', 'e', 'r'] 23 | 24 | seqRange = range(5, 9) 25 | print(list(reversed(seqRange))) #输出 [8, 7, 6, 5] 26 | 27 | seqList = [1, 2, 4, 3, 5] 28 | print(list(reversed(seqList))) #输出 [5, 3, 4, 2, 1] 29 | 30 | a=[1,2,3,4,5,6] 31 | b=reversed(a) 32 | print(b) #输出 显示为一个迭代器 33 | print(list(b)) #输出 [6, 5, 4, 3, 2, 1] 34 | print(list(b)) #输出 [] 35 | 36 | #由此可知：reversed（）返回的是一个迭代器对象，只能进行一次循环遍历。显示一次所包含的值！ 37 | -------------------------------------------------------------------------------- /round函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | round() 方法返回浮点数x的四舍五入值。 4 | 5 | 语法 6 | 以下是 round() 方法的语法: 7 | round( x [, n] ) 8 | 9 | 参数 10 | x -- 数字表达式。 11 | n -- 表示从小数点位数，其中 x 需要四舍五入，默认值为 0。 12 | 13 | 返回值 14 | 返回浮点数x的四舍五入值。 15 | ''' 16 | 17 | print ("round(70.23456) : ", round(70.23456)) 18 | print ("round(56.659,1) : ", round(56.659,1)) 19 | print ("round(80.264, 2) : ", round(80.264, 2)) 20 | print ("round(100.000056, 3) : ", round(100.000056, 3)) 21 | print ("round(-100.000056, 3) : ", round(-100.000056, 3)) 22 | 23 | ''' 24 | 输出结果... 25 | round(70.23456) : 70 26 | round(56.659,1) : 56.7 27 | round(80.264, 2) : 80.26 28 | round(100.000056, 3) : 100.0 29 | round(-100.000056, 3) : -100.0 30 | ''' -------------------------------------------------------------------------------- /setattr函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述： 3 | setattr函数，用于设置属性值，该属性必须存在 4 | 语法： 5 | setattr(object,name,value) 6 | 参数： 7 | object--对象 8 | name--字符串，对象属性 9 | value--属性值 10 | 返回值： 11 | 无 12 | ''' 13 | 14 | class People(): 15 | sex='男' 16 | def __init__(self,name): 17 | self.name=name 18 | def peopleinfo(self): 19 | print('欢迎%s访问'%self.name) 20 | 21 | obj=People('zhangsan') 22 | setattr(People,'x',123) 23 | print(People.x) #等同于 Peopel.x=123 24 | 25 | setattr(obj,'age',18) 26 | print(obj.__dict__) #输出 {'name': 'zhangsan', 'age': 18} 27 | 28 | print(People.__dict__) 29 | #输出 30 | #{'__module__': '__main__', 'sex': '男', '__init__': , 'peopleinfo': , '__dict__': , '__weakref__': , '__doc__': None, 'x': 123} -------------------------------------------------------------------------------- /set函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。 4 | 语法 5 | set 语法： 6 | class set([iterable]) 7 | 参数说明： 8 | iterable -- 可迭代对象对象； 9 | 返回值 10 | 返回新的集合对象。 11 | ''' 12 | 13 | a=set('www.baidu.com') 14 | b=set('www.gogle.com') #重复的元素被删除 元素唯一 可以用来去重 15 | print(a) #输出 {'u', '.', 'm', 'c', 'w', 'd', 'i', 'a', 'o', 'b'} 16 | print(b) #输出 {'.', 'm', 'e', 'c', 'w', 'o', 'l', 'g'} 17 | 18 | print(a&b) #交集 {'m', 'c', 'w', '.', 'o'} 19 | print(a|b) #并集 {'m', 'c', 'i', 'w', 'b', 'd', 'u', 'g', 'e', 'a', '.', 'o', 'l'} 20 | print(a-b) #差集 {'i', 'b', 'd', 'u', 'a'} 21 | 22 | 23 | #1.比较 24 | se = {11, 22, 33} 25 | be = {22, 55} 26 | temp1 = se.difference(be) #找到se中存在，be中不存在的集合，返回新值 27 | print(temp1) #{33, 11} 28 | print(se) #{33, 11, 22} 29 | 30 | temp2 = se.difference_update(be) #找到se中存在，be中不存在的集合，覆盖掉se 31 | print(temp2) #None 32 | print(se) #{33, 11}, 33 | 34 | 35 | #2.删除 36 | se = {11, 22, 33} 37 | se.discard(11) 38 | se.discard(44) # 移除不存的元素不会报错 39 | print(se) 40 | 41 | se = {11, 22, 33} 42 | se.remove(11) 43 | #se.remove(44) # 移除不存的元素会报错 44 | print(se) 45 | 46 | se = {11, 22, 33} # 移除末尾元素并把移除的元素赋给新值 47 | temp = se.pop() 48 | print(temp) # 33 49 | print(se) # {11, 22} 50 | 51 | 52 | #3.取交集 53 | se = {11, 22, 33} 54 | be = {22, 55} 55 | 56 | temp1 = se.intersection(be) #取交集，赋给新值 57 | print(temp1) # 22 58 | print(se) # {11, 22, 33} 59 | 60 | temp2 = se.intersection_update(be) #取交集并更新自己 61 | print(temp2) # None 62 | print(se) # 22 63 | 64 | 65 | #4.判断 66 | se = {11, 22, 33} 67 | be = {22} 68 | 69 | print(se.isdisjoint(be)) #False，判断是否不存在交集（有交集False，无交集True） 70 | print(se.issubset(be)) #False，判断se是否是be的子集合 71 | print(se.issuperset(be)) #True，判断se是否是be的父集合 72 | 73 | 74 | #5.合并 75 | se = {11, 22, 33} 76 | be = {22} 77 | 78 | temp1 = se.symmetric_difference(be) # 合并不同项，并赋新值 79 | print(temp1) #{33, 11} 80 | print(se) #{33, 11, 22} 81 | 82 | temp2 = se.symmetric_difference_update(be) # 合并不同项，并更新自己 83 | print(temp2) #None 84 | print(se) #{33, 11} 85 | 86 | #6.取并集 87 | 88 | se = {11, 22, 33} 89 | be = {22,44,55} 90 | 91 | temp=se.union(be) #取并集，并赋新值 92 | print(se) #{33, 11, 22} 93 | print(temp) #{33, 22, 55, 11, 44} 94 | 95 | 96 | #7.更新 97 | se = {11, 22, 33} 98 | be = {22,44,55} 99 | 100 | se.update(be) # 把se和be合并，得出的值覆盖se 101 | print(se) 102 | se.update([66, 77]) # 可增加迭代项 103 | print(se) 104 | 105 | 106 | #8.集合的转换 107 | se = set(range(4)) 108 | li = list(se) 109 | tu = tuple(se) 110 | st = str(se) 111 | print(li,type(li)) #输出 [0, 1, 2, 3] 112 | print(tu,type(tu)) #输出 [0, 1, 2, 3] 113 | print(st,type(st)) #输出 [0, 1, 2, 3] 114 | 115 | 116 | #参考博客 https://www.cnblogs.com/whatisfantasy/p/5956775.html -------------------------------------------------------------------------------- /slice函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。 4 | 语法 5 | slice 语法： 6 | class slice(stop) 7 | class slice(start, stop[, step]) 8 | 参数说明： 9 | start -- 起始位置 10 | stop -- 结束位置 11 | step -- 间距 12 | 返回值 13 | 返回一个切片对象。 14 | 实例 15 | ''' 16 | 17 | myslice=slice(5) #设置一个 截取五个元素的切片 18 | print(myslice) #输出 slice(None, 5, None) 19 | 20 | arr=list(range(10)) 21 | print(arr) #输出 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 22 | print(arr[myslice]) #输出 [0, 1, 2, 3, 4] 23 | 24 | print(arr[3:6]) #输出 [3, 4, 5] -------------------------------------------------------------------------------- /sorted函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | sorted() 函数对所有可迭代的对象进行排序操作。 4 | sort 与 sorted 区别： 5 | sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。 6 | list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。 7 | 语法 8 | sorted 语法： 9 | sorted(iterable, key=None, reverse=False) 10 | 参数说明： 11 | iterable -- 可迭代对象。 12 | key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。 13 | reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。 14 | 返回值 15 | 返回重新排序的列表。 16 | ''' 17 | 18 | print(sorted([2,3,4,1,5,6])) #输出 [1, 2, 3, 4, 5, 6] 19 | 20 | #另一个区别在于list.sort() 方法只为 list 定义。而 sorted() 函数可以接收任何的 iterable。 21 | print(sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})) #输出 [1, 2, 3, 4, 5] 22 | 23 | #利用key进行倒序排序 24 | example_list = [5, 0, 6, 1, 2, 7, 3, 4] 25 | result_list = sorted(example_list, key=lambda x: x*-1) 26 | print(result_list) #输出 [7, 6, 5, 4, 3, 2, 1, 0] 27 | 28 | #要进行反向排序，也通过传入第三个参数 reverse=True： 29 | example_list = [5, 0, 6, 1, 2, 7, 3, 4] 30 | result_list=sorted(example_list, reverse=True) 31 | print(result_list) #输出 [7, 6, 5, 4, 3, 2, 1, 0] 32 | 33 | #sorted 的应用，也可以通过 key 的值来进行数组/字典的排序，比如 34 | array = [{"age":20,"name":"a"},{"age":25,"name":"b"},{"age":10,"name":"c"}] 35 | array = sorted(array,key=lambda x:x["age"]) 36 | print(array) #输出 [{'age': 10, 'name': 'c'}, {'age': 20, 'name': 'a'}, {'age': 25, 'name': 'b'}] -------------------------------------------------------------------------------- /staticmethod函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | python staticmethod 返回函数的静态方法。 3 | 该方法不强制要求传递参数，如下声明一个静态方法： 4 | class C(object): 5 | @staticmethod 6 | def f(arg1, arg2, ...): 7 | ... 8 | 以上实例声明了静态方法 f，类可以不用实例化就可以调用该方法 C.f()，当然也可以实例化后调用 C().f()。 9 | 函数语法 10 | staticmethod(function) 11 | 参数说明： 12 | 无 13 | ''' 14 | 15 | class C(object): 16 | @staticmethod 17 | def f(): 18 | print('hello world') 19 | C.f() # 静态方法无需实例化 20 | cobj = C() 21 | cobj.f() # 也可以实例化后调用 22 | 23 | 24 | 25 | class A(object): 26 | def foo(self, x): 27 | print("executing foo(%s,%s)" % (self, x)) 28 | print('self:', self) 29 | @classmethod 30 | def class_foo(cls, x): 31 | print("executing class_foo(%s,%s)" % (cls, x)) 32 | print('cls:', cls) 33 | @staticmethod 34 | def static_foo(x): 35 | print("executing static_foo(%s)" % x) 36 | a = A() 37 | print(a.foo) #输出 > 38 | print(a.class_foo) #输出 > 39 | print(a.static_foo) #输出 40 | 41 | #参考博客 https://www.cnblogs.com/elie/p/5876210.html -------------------------------------------------------------------------------- /str函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | str() 函数将对象转化为适于人阅读的形式。 4 | 语法 5 | 以下是 str() 方法的语法: 6 | class str(object='') 7 | 参数 8 | object -- 对象。 9 | 返回值 10 | 返回一个对象的string格式。 11 | ''' 12 | 13 | print(str(1)) #输出 字符串1 14 | print(type(str(1))) #输出 15 | print(str(b'\xe5\xbc\xa0\xe4\xb8\x89',encoding='utf-8')) #输出张三 16 | 17 | dict={'zhangsan':'zhang1234','lisi':'li1234'} 18 | print(type(dict)) #输出 19 | a=str(dict) 20 | print(str(dict)) #输出 字符串 {'zhangsan': 'zhang1234', 'lisi': 'li1234'} 21 | print(type(a)) #输出 -------------------------------------------------------------------------------- /sum函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | sum() 方法对系列进行求和计算。 4 | 语法 5 | 以下是 sum() 方法的语法: 6 | sum(iterable[, start]) 7 | 参数 8 | iterable -- 可迭代对象，如：列表、元组、集合。 9 | start -- 指定相加的参数，如果没有设置这个值，默认为0。 10 | 返回值 11 | 返回计算结果 12 | ''' 13 | 14 | print(sum([0,1,2])) # 列表总和 3 15 | print(sum((2,3,4),1)) # 元组计算总和后再加 1 16 | print(sum([2,3,4,5,6],8)) # 列表计算总和后再加 2 17 | 18 | a = list(range(1,11)) 19 | b = list(range(1,10)) 20 | c = sum([item for item in a if item in b]) 21 | print(c) #输出 45 -------------------------------------------------------------------------------- /vars函数详解.py: -------------------------------------------------------------------------------- 1 | ''' 2 | 描述 3 | vars() 函数返回对象object的属性和属性值的字典对象。 4 | 语法 5 | vars() 函数语法： 6 | vars([object]) 7 | 参数 8 | object -- 对象 9 | 返回值 10 | 返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()。 11 | ''' 12 | 13 | print(vars()) 14 | #输出 {'__name__': '__main__', '__doc__': '\n描述\nvars() 函数返回对象object的属性和属性值的字典对象。\n语法\nvars() 函数语法：\nvars([object])\n参数\nob 15 | 16 | class A: 17 | a=1 18 | __dict__ = 'ltf' 19 | print(vars(A)) 20 | #输出 {'__module__': '__main__', 'a': 1, '__dict__': , '__weakref__': , '__doc__': None} 21 | 22 | a=A() 23 | print(vars(a)) 24 | #输出 ltf 25 | 26 | print(a.__dict__) 27 | #输出 ltf -------------------------------------------------------------------------------- /zip函数详解.py: -------------------------------------------------------------------------------- 1 | #zip函数接受任意多个可迭代对象作为参数,将对象中对应的元素打包成一个tuple,然后返回一个可迭代的zip对象. 2 | #这个可迭代对象可以使用循环的方式列出其元素 3 | #若多个可迭代对象的长度不一致,则所返回的列表与长度最短的可迭代对象相同. 4 | 5 | #1.用列表生成zip对象 6 | x=[1,2,3] 7 | y=[4,5,6] 8 | z=[7,8,9] 9 | h=['a','b','c','d'] 10 | zip1=zip(x,y,z) 11 | print(zip1) 12 | for i in zip1: 13 | print(i) 14 | 15 | zip2=zip(x,y,h) 16 | for i in zip2: 17 | print(i) 18 | 19 | zip3=zip(h) 20 | for i in zip3: 21 | print(i) 22 | 23 | zip4=zip(*h*3) 24 | for i in zip4: 25 | print(i) #这是干啥哟。。 26 | 27 | print('==*=='*10) 28 | #2.二维矩阵变换 29 | l1=[[1,2,3],[4,5,6],[7,8,9]] 30 | print(l1) 31 | print([[j[i] for j in l1] for i in range(len(l1[0])) ]) 32 | zip5=zip(*l1) 33 | for i in zip5: 34 | print(i) --------------------------------------------------------------------------------