当前位置: 澳门新濠3559 > 编程 > 正文

内置函数,集合不可修改澳门新濠3559

时间:2019-11-29 05:49来源:编程
冒泡法1.冒泡:每次比较相邻的两个元素,不合适就交换,依次向后,一圈下来可以确定一个元素 2.需要使用双重循环,外层循环控制循环的圈数, 内层控制一圈怎么交换 lanbda表达式

冒泡法 1.冒泡:每次比较相邻的两个元素,不合适就交换,依次向后,一圈下来可以确定一个元素
2.需要使用双重循环,外层循环控制循环的圈数, 内层控制一圈怎么交换

lanbda表达式

  • lanbda表达式只适用于简单的函数,不能表示复杂的函数表达式
  • 函数名 = lanbda : 函数体
  • 函数名 = lanbda 参数1,参数2,... : 返回值
fun = lambda str, num: int(str) + num
ret = fun('100', 100)
print('reslut is',ret)

内建函数built-in function

  1. abs(x) :返回x的绝对值absolute value
  2. all(iterable )
    参数:iterable -- 元组或列表。
    如果iterable的所有元素不为0、''、False或者iterable为空,all(iterable)返回True,否则返回False;
    注意:空元组、空列表返回值为True,这里要特别注意。
>>>all(['a', 'b', 'c', 'd'])  # 列表list,元素都不为空或0
True
>>> all(['a', 'b', '', 'd'])   # 列表list,存在一个为空的元素
False
>>> all([0, 1,2, 3])          # 列表list,存在一个为0的元素
False   
>>> all(('a', 'b', 'c', 'd'))  # 元组tuple,元素都不为空或0
True
>>> all(('a', 'b', '', 'd'))   # 元组tuple,存在一个为空的元素
False
>>> all((0, 1,2, 3))          # 元组tuple,存在一个为0的元素
False 
>>> all([])             # 空列表
True
>>> all(())             # 空元组
True
  1. any(iterable)
    参数
    iterable -- 元组或列表。
    返回值
    如果都为空、0、false,则返回false,如果不都为空、0、false,则返回true。
>>>any(['a', 'b', 'c', 'd'])  # 列表list,元素都不为空或0
True 
>>> any(['a', 'b', '', 'd'])   # 列表list,存在一个为空的元素
True 
>>> any([0, '', False])        # 列表list,元素全为0,'',false
False 
>>> any(('a', 'b', 'c', 'd'))  # 元组tuple,元素都不为空或0
True 
>>> any(('a', 'b', '', 'd'))   # 元组tuple,存在一个为空的元素
True 
>>> any((0, '', False))        # 元组tuple,元素全为0,'',false
False  
>>> any([]) # 空列表
False 
>>> any(()) # 空元组
False
  1. bin(x):返回int或者long int的二进制形式
    类似的:hex() 函数用于将10进制整数转换成16进制整数。
    oct(),将十进制转换为八进制
>>>bin(10)
'0b1010'
>>> bin(20)
'0b10100'
>>>hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
>>> hex(1L)
'0x1L'
print(oct(7))#>>>>>>0o7
  1. bool():将给定参数转换为布尔类型,如果没有参数,返回 False。
>>>bool()
False
>>> bool(0)
False
>>> bool(1)
True
>>> bool(2)
True
  1. callable(object):检查一个对象是否是可调用的。
    如果返回True,object仍然可能调用失败;但如果返回False,调用对象ojbect绝对不会成功。
    对于函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True。
>>>callable(0)
False
>>> callable("runoob")
False 
>>> def add(a, b):
...     return a + b
... 
>>> callable(add)             # 函数返回 True
True
>>> class A:                  # 类
...     def method(self):
...             return 0
... 
>>> callable(A)               # 类返回 True
True
>>> a = A()
>>> callable(a)               # 没有实现 __call__, 返回 False
False
>>> class B:
...     def __call__(self):
...             return 0
... 
>>> callable(B)
True
>>> b = B()
>>> callable(b)               # 实现 __call__, 返回 True
True
  1. chr(i):返回值是当前整数(0-255)对应的ascii字符。
>>>print chr(0x30), chr(0x31), chr(0x61)   # 十六进制
0 1 a
>>> print chr(48), chr(49), chr(97)         # 十进制
0 1 a
  1. ord():与chr(i)的功能正好相反。
  2. classmethod 修饰符对应的函数不需要实例化,不需要 self 参数,但第一个参数需要是表示自身类的 cls 参数,可以来调用类的属性,类的方法,实例化对象等。
#!/usr/bin/python
# -*- coding: UTF-8 -*- 
class A(object):
    bar = 1
    def func1(self):  
        print 'foo'  
    @classmethod
    def func2(cls):
        print 'func2'
        print cls.bar
        cls().func1()   # 调用 foo 方法 
A.func2()               # 不需要实例化

输出结果为:
func2
1
foo

  1. compile() 函数将一个字符串编译为字节代码。
>>>str = "for i in range(0,10): print(i)" 
>>> c = compile(str,'','exec')   # 编译为字节代码对象 
>>> c
<code object <module> at 0x10141e0b0, file "", line 1>
>>> exec(c)
0
1
2
3
4
5
6
7
8
9
>>> str = "3 * 4 + 5"
>>> a = compile(str,'','eval')
>>> eval(a)
17
  1. complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串,则不需要指定第二个参数
>>>complex(1, 2)
(1 + 2j) 
>>> complex(1)    # 数字
(1 + 0j) 
>>> complex("1")  # 当做字符串处理
(1 + 0j) 
# 注意:这个地方在"+"号两边不能有空格,也就是不能写成"1 + 2j",应该是"1+2j",否则会报错
>>> complex("1+2j")
(1 + 2j)
  1. delattr 函数用于删除属性。
    delattr(x, 'foobar') 相等于 del x.foobar。
class Coordinate:
    x = 10
    y = -5
    z = 0
point1 = Coordinate() 
print('x = ',point1.x)
print('y = ',point1.y)
print('z = ',point1.z) 
delattr(Coordinate, 'z') 
print('--删除 z 属性后--')
print('x = ',point1.x)
print('y = ',point1.y) 
# 触发错误
print('z = ',point1.z)
  1. dict()函数用于创建一个字典。
>>>dict()                        # 创建空字典
{}
>>> dict(a='a', b='b', t='t')     # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
{'three': 3, 'two': 2, 'one': 1} 
>>> dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
{'three': 3, 'two': 2, 'one': 1}
  1. divmod() 函数把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b)。
>>>divmod(7, 2)
(3, 1)
>>> divmod(8, 2)
(4, 0)
>>> divmod(1+2j,1+0.5j)
((1+0j), 1.5j)
  1. enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。
>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))       # 小标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

for 循环使用 enumerate

>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
...     print i, seq[i]
... 
0 one
1 two
2 three
  1. eval() 函数用来执行一个字符串表达式,并返回表达式的值。
>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> eval("n + 4")
85
  1. execfile() 函数可以用来执行一个文件。
假设文件 hello.py,内容如下:
`print('runoob');`
execfile 调用该文件
>>>execfile('hello.py')
runoob
  1. filter():过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。
    该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判,然后返回 True 或 False,最后将返回 True 的元素放到新列表中。
#!/usr/bin/python
# -*- coding: UTF-8 -*- 
def is_odd(n):
    return n % 2 == 1 
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)
  1. float() 函数用于将整数和字符串转换成浮点数。
>>> float('+1.23')
1.23
>>> float('   -12345n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf
  1. frozenset() 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。
>>>a = frozenset(range(10))     # 生成一个新的不可变集合
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset('runoob') 
>>> b
frozenset(['b', 'r', 'u', 'o', 'n'])   # 创建不可变集合
>>>
  1. format():格式化输出字符串,format(value, format_spec)实质上是调用了value的format(format_spec)方法。
    print("i am {0},age{1}".format("tom",18))#>>>>>>i am tom,age18
  2. getatt() 函数用于返回一个对象属性值。
    getattr(x, 'foobar') 等价于 x.foobar.
>>>class A(object):
...     bar = 1
... 
>>> a = A()
>>> getattr(a, 'bar')        # 获取属性 bar 值
1
>>> getattr(a, 'bar2')       # 属性 bar2 不存在,触发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'bar2'
  1. hasattr() 函数用于判断对象是否包含对应的属性。
    如果对象有该属性返回 True,否则返回 False。
class Coordinate:
    x = 10
    y = -5
    z = 0
point1 = Coordinate() 
print(hasattr(point1, 'x'))  # true
print(hasattr(point1, 'y'))  # true
print(hasattr(point1, 'z'))  #true
print(hasattr(point1, 'no'))  # 没有该属性false
  1. hash() 用于获取取一个对象(字符串或者数值等)的哈希值。
hash(1)
1
hash('test')
2314058222102390712
  1. id() 函数用于获取对象的内存地址。
>>>a = 'runoob'
>>> id(a)
4531887632
>>> b = 1
>>> id(b)
140588731085608
  1. int():将字符串或者其他进制的数字转化为整形。
>>>int()               # 不传入参数时,得到结果0
0
>>> int(3)
3
>>> int(3.6)
3
>>> int('12',16)        # 如果是带参数base的话,12要以字符串的形式进行输入,12 为 16进制
18
>>> int('0xa',16)  
10  
>>> int('10',8)  
8
  1. isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()。

isinstance() 与 type() 区别:
type() 不会认为子类是一种父类类型,不考虑继承关系。
isinstance() 会认为子类是一种父类类型,考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。

a = 2 isinstance (a,int) True isinstance (a,str) False isinstance (a,(str,int,list)) # 是元组中的一个返回 True True

type() 与 isinstance()区别:

class A:
    pass 
class B(A):
    pass
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False
  1. bytes()  将一个字符串转换成字节类型
s="apple"
v=bytes(s,encoding="utf-8")
print(v)#>>>>>>b'apple'
  1. str()  将字符类型/数值类型等转换为字符串类型
1 s=100
2 print(type(s))#>>>><class 'int'>
3 s=str(s)
4 print(type(s))#>>>><class 'str'>
  1. len():返回对象长度,参数可以是序列类型(字符串,元组或列表)或映射类型(如字典)
>>> a=[1, 2, 3, 4]
>>> len(a)
4
>>> type(a)
<class 'list'>
>>> a=(1, 2, 3, 4)
>>> type(a)
<class 'tuple'>
>>> a=['list', 'adwd', 'awde']
>>> type(a)
<class 'list'>
>>> len(a)
3
>>> a='sefijefs'
>>> len(a)
8
  1. list():元组转化列表
aTuple = (123, 'xyz', 'zara', 'abc');
aList = list(aTuple)
print ("列表元素 : ", aList)
结果:
列表元素 :  [123, 'xyz', 'zara', 'abc']
  1. tuple(): 列表转化元组。与list()类似
  2. locals() 函数会以字典类型返回当前位置的全部局部变量。
>>>def runoob(arg):    # 两个局部变量:arg、z
...     z = 1
...     print locals()
... 
>>> runoob(4)
{'z': 1, 'arg': 4}      # 返回一个名字/值对的字典
  1. map():根据提供的函数对指定序列做映射。
>>>def square(x) :            # 计算平方数
...     return x ** 2
>>> map(square, [1,2,3,4,5])   # 计算列表和:1+2+3+4+5
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
# 提供了两个列表,对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]
  1. max() 方法返回给定参数的最大值,参数可以为序列。
  2. min()同样的用法
  3. iter() 函数用来生成迭代器。
>>>lst = [1, 2, 3]
>>> for i in iter(lst):
...     print(i)
... 
1
2
3
  1. next():返回迭代器的下一个项目。
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break
  1. open() 函数用于打开一个文件,创建一个 file 对象,相关的方法才可以调用它进行读写。
    file 对象方法
    file.read([size]) size未指定则返回整个文件,如果文件大小>2倍内存则有问题.f.read()读到文件尾时返回""(空字串)
    file.readline() 返回一行
    file.readline([size]) 返回包含size行的列表,size 未指定则返回全部行
    for line in f: print line #通过迭代器访问
    f.write("hellon") #如果要写入字符串以外的数据,先将他转换为字符串.
    f.tell() 返回一个整数,表示当前文件指针的位置(就是到文件头的比特数).
    f.seek(偏移量,[起始位置]) 用来移动文件指针.
    偏移量:单位:比特,可正可负
    起始位置:0-文件头,默认值;1-当前位置;2-文件尾
    f.close() 关闭文件
>>>f = open('test.txt')
>>> f.read()
'RUNOOB1nRUNOOB2n'
  1. pow() 方法返回 x的y次方 的值。
    以下是 math 模块 pow() 方法的语法:
import math
math.pow( x, y )

内置的 pow() 方法
pow(x, y[, z])
函数是计算x的y次方,如果z在存在,则再对结果进行取模,其结果等效于pow(x,y) %z
注意:pow() 通过内置的方法直接调用,内置方法会把参数作为整型,而 math 模块则会把参数转换为 float。

import math   # 导入 math 模块
print "math.pow(100, 2) : ", math.pow(100, 2)
# 使用内置,查看输出结果区别
print "pow(100, 2) : ", pow(100, 2)
print "math.pow(100, -2) : ", math.pow(100, -2)
print "math.pow(2, 4) : ", math.pow(2, 4)
print "math.pow(3, 0) : ", math.pow(3, 0)
结果:
math.pow(100, 2) :  10000.0
pow(100, 2) :  10000
math.pow(100, -2) :  0.0001
math.pow(2, 4) :  16.0
math.pow(3, 0) :  1.0

pow(x,y) 等价于 x**y:
4**2 # 结果为16
4**2.5 # 结果为32.0
pow(x,y,z) 等价于 x**y%z:
4**2.5%3 # 结果为2.0

  1. range():函数可创建一个整数列表,一般用在 for 循环中。
>>>range(10)        # 从 0 开始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)     # 从 1 开始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)  # 步长为 5
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)  # 步长为 3
[0, 3, 6, 9]
>>> range(0, -10, -1) # 负数
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]
  1. repr() 返回一个对象的 string 格式。
>>>s = 'RUNOOB'
>>> repr(s)
"'RUNOOB'"
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>>repr(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
  1. reverse() 函数用于反向列表中元素。
aList = [123, 'xyz', 'zara', 'abc', 'xyz'];
aList.reverse();
  1. round() 方法返回浮点数x的四舍五入值。round() 方法返回浮点数x的四舍五入值。
round(80.23456, 2) :  80.23
round(100.000056, 3) :  100.0
round(-100.000056, 3) :  -100.0
  1. slice() 函数实现切片对象,主要用在切片操作函数里的参数传递。
>>>myslice = slice(5)    # 设置截取5个元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice]         # 截取 5 个元素
[0, 1, 2, 3, 4]
  1. sorted()  排序
    sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别:
sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。

a = [5,7,6,3,4,1,2] b = sorted(a) # 保留原列表 a [5, 7, 6, 3, 4, 1, 2] b [1, 2, 3, 4, 5, 6, 7] L=[('b',2),('a',1),('c',3),('d',4)] sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) # 利用cmp函数 [('a', 1), ('b', 2), ('c', 3), ('d', 4)] sorted(L, key=lambda x:x[1]) # 利用key [('a', 1), ('b', 2), ('c', 3), ('d', 4)] students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] sorted(students, key=lambda s: s[2]) # 按年龄排序 [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] sorted(students, key=lambda s: s[2], reverse=True) # 按降序 [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

  1. zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表。
>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 与 zip 相反,可理解为解压,返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]

文件操作

  

 

 

深浅拷贝

  • 对于 数字 和 字符串 而言,赋值、浅拷贝和深拷贝无意义,因为其永远指向同一个内存地址
import copy
# ######### 数字、字符串 #########
n1 = 123
# n1 = "i am alex age 10"
print(id(n1))
# ## 赋值 ##
n2 = n1
print(id(n2))
# ## 浅拷贝 ##
n2 = copy.copy(n1)
print(id(n2))

# ## 深拷贝 ##
n3 = copy.deepcopy(n1)
print(id(n3))
# ===>
1485856400
1485856400
1485856400
1485856400
  • 对于字典、元祖、列表 而言,进行赋值、浅拷贝和深拷贝时,其内存地址的变化是不同的。
    • 赋值
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}

n2 = n1
  • 澳门新濠3559 1

    image

    • 浅拷贝
    • 浅拷贝,在内存中只额外创建第一层数据
import copy
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n3 = copy.copy(n1)
  • 澳门新濠3559 2

    iamge

    • 深拷贝
    • 深拷贝,在内存中将所有的数据重新创建一份(排除最后一层,即:python内部对字符串和数字的优化)
import copy
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n4 = copy.deepcopy(n1)
  • 澳门新濠3559 3

    iamge

1. 知识回顾

常用函数:
abs 求绝对值
enumerate 枚举可迭代对象
pow 求幂,pow(2,3) == 2**3
hex 转换为16进制
oct 转换为8进制
bin 转换为2进制
常见模块函数:
random :
randint:生成随机的整数
random:生成0~1的小数
uniform:生成指定返回的随机浮点数
choice:从传入的对象中随机抽取一个元素
sample:从传入的对象中随机抽取指定个元素,组成
一个列表返回
choices:sample的抽取一个元素的形式
shuffle:打乱传入的对象
math :
ceil:向上取整
floor:向下取整
sqrt: 平方根
degrees:弧度转换为度
randians:度转换为弧度
字符串函数
join:
strip:过滤两边的特定字符,默认是空白字符
replace:字符替换,可以指定替换次数
split:字符串切割,可以指定切割次数,从左边切 割
splitlines:按照换行切割
upper:全大写
lower:全小写
swapcase;大小写转换
capitalize: 首字符大写
title: 每个单词首字母大写
count:统计某个字符出现的次数
isdecimal:是否是数字
isalpha:是否是字母
isalnum:是否是数字或字母
列表函数:
append:追加元素
remove:删除元素
extend:将可迭代的对象挨个遍历然后添加
count:统计某个元素出现的次数
index:返回某个对象在列表中的第一个索引,不存
在则报错
insert:在指定的位置插入元素
pop:弹出最后一个元素,可以指定索引

函数

  • 函数式编程最重要的是增强代码的重用性和可读性
  • 参数类型
    • 普通参数
    • 默认参数
      • 注:默认参数需要放在参数列表最后
    • 动态参数
def func(name, age=18):
    print(name)
    print(age)

func("你好,世界")
func("Hello World", 19)  # 注:默认参数需要放在参数列表最后

def func(*args):
    print(args)
func(1, 2, 3, 4, 5, 6, 7)
func(*[11,22,33,44,55,66]) # 直接传入可迭代的类型,在前面加 * 

# 打印是一个元组

def func(**kwargs):
    print args

# 执行方式一
func(name='余浩宏', age=20, gender='man')

# 执行方式二
dic = {'name': '张三', 'age': 19, 'gender': 'man'}
func(**dic) # 直接传入字典,在前面加入** 
  • 字符串、字典、列表最重要
  • set集合没它们这么重要

处理字典 列表等有两种方式:1改变自身  *2返回新建的变量*

# def qu2(args):
#     r = {}
#     for key, value in args.items():
#         if len(value) > 2:
#             r[key] = value[0:2]
#         else:
#             r[key] = value
#     return r
#
# l = {'k1': 'xascaasdx', 'k2': 'cf', 'k3': [11,22,33]}
# print(qu2(l))

>>>>>>>>>>>>>>>>>>>>>>>>>>两种方法

def qu2(args):
    for key, value in args.items():
        if len(value) > 2:
            args[key] = value[0:2]
        else:
            args[key] = value

l = {'k1': 'xascaasdx', 'k2': 'cf', 'k3': [11,22,33]}
qu2(l)
print(l)

  

ord 将字符转换为ASCII
chr 将ASCII转换为字符

三元运算符

#三元运算符
num = 60
ret = 100 if num > 100 else num
print(ret)

  sorted() 排序顺序

  对数字来说,从小到大

  对字符串来说, 先数字,后字母字符,最后汉字

  

l = [ '你好','11', 'yadlan', '1324', '23', '546', 'rruhvd', 'Ancskdna', 'Av s,', '好啊']

r = sorted(l)

print(r)
for i in r:
    print(bytes(i, encoding = 'utf-8'))

#>>>>>>>>>>>>
['11', '1324', '23', '546', 'Ancskdna', 'Av s,', 'rruhvd', 'yadlan', '你好', '好啊']
b'11'
b'1324'
b'23'
b'546'
b'Ancskdna'
b'Av s,'
b'rruhvd'
b'yadlan'
b'xe4xbdxa0xe5xa5xbd'
b'xe5xa5xbdxe5x95x8a'

    

元组不可修改,当只有一个元素时,要添加一个逗号
集合不可修改,元素无序,不能重复

内置函数

  • 10进制转其他进制

    • int():转成10进制
    • hex():转成16进制
    • bin():转成2进制
    • oct():转成8进制
    ten2bin = bin(100)
    print(ten2bin) # 0b1100100
    
    ten2eight = oct(100)
    print(ten2eight) # 0o144
    
    ten2hex = hex(100)
    print(ten2hex) # 0x64
    
  • 其他进制转10进制

    • int(str, base=2/8/10/16)
    bin2ten = int("0x64",base=16)
    print(bin2ten)
    
  • str -- bytes转换

    b = bytes('HelloWorld', encoding='utf-8')
    s = str(b, encoding='utf-8')
    print(s)
    
  • isinstance():判断实例是否属于这个类

  • all():传入interable参数,底层循环遍历所有的值,如果都为True,则返回True

    • False 、 None 、 [] 、{} 、'' 、0 、"" 为False
    """
    Return True if bool(x) is True for all values x in the iterable.
    If the iterable is empty, return True.
    """
    ret = all([1,2,3,0]) # 有0为False
    print(ret)
    
  • any():和all一样,如果有一个为True,则返回True

    • False 、 None 、 [] 、{} 、'' 、0 、"" 为False
    """
    Return True if bool(x) is True for any x in the iterable.
    If the iterable is empty, return False.
    """
    
  • ascii():传入对象,会自动调用对象的__repr__方法,或去返回的值

  • boolean():根据传入的参数转为boolean

    b = bool(0)# False
    b = bool(1)# True
    b = bool('')# False
    b = bool([])# False
    b = bool({})# False
    b = bool(None)# False
    
  • abs():取绝对值

  • bytes:

  • bytesarr:

    • 将字符串转为字节和字节数组,类似与字符串和列表
    b = bytes('string', encoding='utf-8')
    print(b)
    for i in b:
        print(i, "", end='')
    print('')
    bs = bytearray('string', encoding='utf-8')
    for i in bs:
        print(i, "", end='')
    #115 116 114 105 110 103 
    #115 116 114 105 110 103 
    
  • chr():传入数字,转成acsii对应的字符

  • ord():传入字符,返回acsii对应的编码

    • 只适用于ascii码表
    chart = chr(65)
    print(chart) # A
    order = ord('a')
    print(order) # 97
    
    • str():
  • callable():是否和执行,传入的对象后面加()是否有代码执行

    • 如:创建对象,调用方法
  • compile(str):编译,将字符串传入,编译成代码执行

  • dir():查看方法

  • help():查看详情

  • divmod():除法,返回一个tuple(商,余),用于分页

    ret = divmod(10, 3)
    print(ret) # (3, 1)
    
  • eval():执行字符串代码,有返回值(简单)

    • 在一些excle文档中有这样的需求:
    string = '1 + 3'
    ret = eval(string)
    print(ret)
    
  • exec():执行字符串代码,没有返回值(复杂)

    string = '''
    for i in range(10):
        print('Hello World')
    '''
    exec(string)
    
  • filter('函数',iterable):

    • 参数1为过滤函数,范围值通过boolean()转换为True,则保存起来,否则不保存
    • 参数2为可迭代类型,通过for循环取出来作为参数传入函数
    • 返回值为函数结果为True的参数,通过迭代可以取值
    li = [11,22,33,44,55]
    ret = filter(lambda num:True if num > 22 else False, li)
    for i in ret:
        print(i) # 33 44 55
    
  • map('函数',iterale):

    • 函数没有返回值
    • 参数通过for循环取出来作为参数传入函数
    li = [11,22,33,44,55]
    
    def addMethod(num):
        num += 100
        return num
    ret = map(addMethod, li)
    
    for i in ret:
        print(i)
    
  • globals():获取所有的全局变量

  • locals():获取所有的局部变量

  • hash():获取hash值,一般用作键值

  • iter():传入可被迭代的数,和next()函数并用

  • next():取下一个值

    li = [11, 22, 33, 44, 55, 66]
    it = iter(li)
    item = next(it)
    print(item) # 11
    item = next(it)
    print(item) # 22
    
  • max():取最大值

  • min():取最小值

  • pow(2,3):2的3次方

  • reverse():反转

  • rount():四舍五入

  • sorted():排序

  • zip(iterable, iterable):

    li1 = [1, 2, 3, 4, 5, 6]
    li2 = ['a', 'b', 'c', 'd', 'e', 'f']
    ret = zip(li1, li2)
    for item in ret:
        print(item)
    # ===>
    (2, 'b')
    (3, 'c')
    (4, 'd')
    (5, 'e')
    (6, 'f')
    
  • --import--()

    r = __import__('random')
    a = r.random()
    print(a)
    
  • sorted:

    • 参数传入可得到的类型,且元素必须是同一种类型,然后会调用参数的sort方法
    • 返回排序后的变量
    li = [22, 33, 11, 77, 55, 99]
    new_li = sorted(li)
    print(new_li)
    li.sort()
    print(li)
    
    • 验证码
import random
ret = ''
for i in range(4):
    numOrStr = random.randrange(4)
    if numOrStr == 0 or numOrStr == 3:
        strIndex = random.randint(97, 122)
        c = chr(strIndex)
        ret += c
    else:
        strNum = str(random.randint(0, 9))
        ret += strNum
print('验证码:', ret)

  0 None "" [] () {} 为False , 其他为True

  abs() 取绝对值

  all()   循环参数,若每个元素都为True, 返回真

  any() 循环参数,只要有一个True, 返回True

  ascii()  去参数对象的类中寻找 __repr__() 方法, 执行获取返回值

  bin()  二进制

  oct() 八进制

  int() 十进制      ret = int('0b1010', base=2)   ---->    将二进制转为十进制

  hex()  十六进制

  bool() 判断真假,即将参数转为布尔值

  bytes()        字节

  bytearray()  字节数组,每一个元素为字节, 类似 字符串跟列表的关系

  chr()  接收一个十进制数,返回对应ASCII码的字符

  ord()  与 chr() 相反,接收一个字符,返回ASCII对应十进制数

选择法:每一次从待排序的数据元素中选出(最小或最大)的一个元素,存放在序列的起始位置,直到全部排序完毕。

set集合

  • set集合是无序无索引不可重复的
s = set([11,22,33,44,55])
print(s)
# ==> {33, 11, 44, 22, 55}
  • set集合可以修改,如果重复添加,只会保存一个
  • 创建空的set集合
s = set()
print(type(s)) # {} type = set
s = {}
print(type(s)) # {} type = dict
# 如果通过第二种方式创建,默认创建的是字典,所以创建空的set集合用第一种方式
  • 创建set集合
s = set('abcdefg')
print(s)
s = set([11, 22, 33, 44])
print(s)
s = set(('aa', 'bb', 'cc'))
print(s)
# ===>
{'e', 'b', 'g', 'a', 'c', 'f', 'd'}
{33, 11, 44, 22}
{'bb', 'aa', 'cc'}
# 参数的类型必须是可迭代的
  • set集合的方法
    • add(arg):添加元素,如果set集合里有,则不会重复保存
s = set() # 创建一个空的集合
num1 = -10000
print("num1的内存地址为:", id(num1))  # 内存地址:16377440
s.add(num1)
num2 = -10000
print("num2的内存地址为:", id(num2))  # 内存地址:16377456
s.add(num2)
getNum = s.pop()
print("获取最新的内存地址:", id(getNum)) # 内存地址为第一次添加的地址,第二个没有保存进去
    • clear:清空集合
    • difference:比对像个集合A.difference(B),把A有B没有的元素返回到新给集合
    • difference_update:比对A、B集合,把A中与B公共的元素去除,直接操作A集合
A = set([11,22,33,44,55,66])
B = set([11,33,55,77,99])
return_set = A.difference(B)
print(return_set)   # {66, 44, 22}

A.difference_update(B)
print(A)            # {66, 44, 22}
    • discard:丢弃,删除,若不存在不会报错
    • remove:移除,若不存在则报错
s = {11,22,33,44,55,66}
s.discard(11)
print(s)
s.discard(77)
print(s)
s.remove(22)
print(s)
s.remove(99)
print(s)
    • updata:更新,参数为可迭代类型,内部通过for循环add进入
s = set()
li = [11, 22, 33, 44, 55, 66]
s.update(li)
print(s)
string = 'Hello_World'
s.update(string)
print(s)
    • issupset:是否是父集合
    • issubset:是否是子集合
s1 = {11, 22, 33, 44}
s2 = {11, 22, 33, 44, 55, 66, 77, 88}
print(s1.issubset(s1))
print(s2.issuperset(s1))
===>
True
True
    • pop:移除元素并返回值,由于set集合是无序的,删除的元素不一定是新增的元素
# pop:删除元素并返回值
s = {11, 22, 33, 44, 55, 66}
print(s)
popEle = s.pop()
print(popEle)
    • isdisjoint:是否没有交集,没有交集返回True
    • symmetric_difference:对称差集,把两个集合合并,同时去除交集
    • union:并集
    • update:更新,接收可迭代参数

  改进为 既包含数字 又包含字母的

import random

temp = ''
for i in range(6):
    rd = random.randrange(0, 4)
    if rd == 1 or rd == 3:
        num1 = random.randrange(0, 10)
        temp += str(num1)
    else:
        num = random.randrange(65, 91)  # 65~90 A~Z
        ch = chr(num)
        temp += ch

print(temp)   #随机生成6位验证码

  

  callable()   检测参数是否是可执行的

  compile()   把字符串编译成可执行代码,可以与exec()结合使用

  dir() 返回对象所在类里的所有方法

  help() 输出类的所有详细信息

  divmod()   divmod(a, b)   返回a/b的 商 和 余数 组成的元组,可以用在 分页 中

  eval()  执行一个字符串格式的表达式

ret = eval('1 + 3 * 2')

print(ret)

#>>>>>>>>>>>

7

  后面可以带字典指定字符串中的变量值

ret = eval('a + 10', {'a':23})
#后面带字典,指定变量的值
print(ret)

#>>>>>>>>>>>
33

  exec()  执行字符串形式的代码,没有返回值  

exec('for i in range(10): print(i)')

#>>>>>>>>>
0
1
2
3
4
5
6
7
8
9

  filter()      filter(函数名, 可迭代的对象)  循环取后者的元素,作为函数的参数,执行。若返回True, 保存该元素

        即 过滤出符合条件的元素

def f1(args):
    if args > 22:
        return True
    else:
        return False

ret = filter(f1, [11, 22, 33, 44])

print(ret)

for i in ret:
    print(i)

#通过lambda表达式
ret = filter(lambda x: x > 22, [11, 22, 33, 44])

print(ret)

for i in ret:
    print(i)

#>>>>>>>>>>>

<filter object at 0x00000238C7A7CE48>
33
44
<filter object at 0x00000238C7A7CE80>
33
44

  map()   跟filter() 类似,不同在于 对每个元素做统一的处理

def f1(args):
    return args + 100

ret = map(f1, [11, 22, 33, 44])

print(ret)

for i in ret:
    print(i)

#通过lambda表达式
ret = map(lambda x: x + 100, [11, 22, 33, 44])

print(ret)

for i in ret:
    print(i)

#>>>>>>>>>>>
<map object at 0x000001BF2210CE48>
111
122
133
144
<map object at 0x000001BF2210CE80>
111
122
133
144

  

def f1(args):
    if args % 2 == 0:
        return args + 100
    else:
        return args

ret = map(f1, [11, 22, 33, 44])

print(ret)

for i in ret:
    print(i)

#通过lambda表达式
ret = map(lambda x: x + 100 if x % 2 == 0 else x, [11, 22, 33, 44])

print(ret)

for i in ret:
    print(i)

#>>>>>>>>>>>

<map object at 0x000001FF537FCE48>
11
122
33
144
<map object at 0x000001FF537FCE80>
11
122
33
144

  locals()  获取所有局部变量

  globals()   获取所有全局变量

def f1():
    n1 = 123
    print(locals())
    print(globals())

l = [11,22,33]

f1()

#>>>>>>>>>>>>>>>>>>>>>

{'n1': 123}
{'__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001F7B1AEAA58>, 'f1': <function f1 at 0x000001F7B1BB10D0>, '__spec__': None, 'l': [11, 22, 33], '__file__': 'C:/Users/LiuKai/PycharmProjects/Fighting/main/src.py', '__package__': None, '__builtins__': <module 'builtins' (built-in)>, '__doc__': None, '__name__': '__main__', '__cached__': None}

  id() 内存地址

  hash() 返回其哈希值

  iter() 转为可迭代的对象,使用next()取值,每执行一次next()取下一个值

  max() min() 取最大值 最小值 sum() 求和

  pow() 指数运算 pow(2, 10) = 1024

  repr() 类似 ascii() , 不过 ascii() 遇到中文会转义

  reversed() 反转 需要在迭代(for循环)中取出元素

  round() 四舍五入

  zip() 把对应的元素组成一个元组作为一个元素

l = [11, 22, 33, 44, 55]
m = ['qq', 'ss', 'dd', 'dd']
n = ['@@', '##', '$$', '%%']

r = zip(l, m, n)

for i in r:
    print(i)

#>>>>>>>>>
(11, 'qq', '@@')
(22, 'ss', '##')
(33, 'dd', '$$')
(44, 'dd', '%%')

  __import__() 也是导入模块,r = __import__(random), 之后再用到时使用 r.randomrange() 相当于起了一个别名

 

reverse:逆序
sort:排序
copy:拷贝
clear:清空
集合函数
add:添加元素
updata:将可迭代对象中的所有元素挨个添加
remove:删除指定的元素,没有会报错
discard:删除指定元素,没有也不报错
pop:随机弹出一个元素
issubset;是否是子集
issuperset:是否是父集
isdisjoint:是否没有交集

http://www.cnblogs.com/wupeiqi/articles/5453708.html

2. lambda表达式

  简易的表示函数

def f1(a1, a2):
    return a1 + a2

f2 = lambda a1, a2: a1 + a2

r1 = f1(1, 2)
r2 = f2(1, 2)

print(r1)
print(r2)

#>>>>>>>>>
3
3

 

列表、元组、字典都是可迭代对象,就是可以遍历的对象
多层循环的时候,外层控制次数,内层用来循环每一次应该怎么做

3. 内置函数

澳门新濠3559 4

 

  isinstance(object, class)   ---->   判断该对象是否是该类的实例

s = 'cnskcsk'

ret = isinstance(s, str)

print(ret)

#>>>>>>>>>>>>>>>
True

  

  传入 列表 字典 集合 时,默认传入的是实参的引用地址,即可以修改实参

def app(args):
    args.append('333')
    return args

li = [11,22]
ret = app(li)
print(li)

#>>>>>>>>>>>
[11, 22, '333']

  一旦对形参进行赋值操作,就新开辟一块内存使args指向这块新开辟的,而实参不变

def app(args):
    args = 'qweqweqwe'
    return args

li = [11,22]
ret = app(li)
print(li)

#>>>>>>>>>>>
[11, 22]

  

  小例子:生成随机验证码

import random

temp = ''
for i in range(4):
    num = random.randrange(65, 91) #65~90 A~Z
    ch = chr(num)
    temp += ch

print(temp)   #随机生成四位验证码

编辑:编程 本文来源:内置函数,集合不可修改澳门新濠3559

关键词: