python基础数据类型

发表于 | 更新于 | 分类于

数据类型：数字，字符串，列表，元组，集合，字典

数字
1
2
3
4
5
6
7
整数：int
浮点数：float
布尔值：大小写敏感  非空非零为真，0或空为假
复数：以J或j结尾，

type(判断谁)
		查看类型
字符串
1
2
3
4
5
6
7
8
9
10
11
12
字符串里面的东西是无意义的
索引：从左到右，从0开始，从右到左，从-1开始
切片：左闭右开
    a[start:stop(不取):step]
    step 步长  start起点 stop终点(不取)
	同符号情况下，如果步长是负数，那么应该从大到小
				start > stop
	如果步长是个正的，那么从小大到
			start > stop
字符串是一个不可变数据类型
	一般对于不可变数据的函数处理，操作只会返回一个新的值，不会影响自己本身
	字符串支持 加法和乘法  分别是拼接和多次输出
列表
1
2
3
4
5
6
7
8
9
10
11
12
13
列表(list)
	语法:  a = [1,2,3,4,5]
	支持索引和切片
	一个列表里可以存储任意的数据类型
	可以创建一个空列表
	列表可变，可以通过索引访问修改
通过切片重新赋值
	切片修改的时候，只要给的值和坑对应了就行
列表的范围赋值：
	切片赋值：
		步长绝对值为1时，取一个数据集合的每一个值，放置到这个之前的位置
		步长绝对值大于1时，一个萝卜一个坑，要一一对应
	切片的步长包含起点
元组
1
2
3
4
5
6
元组(tuple) 
	()
	不可变
	创建一个只含有一个数据的元组
		a = ('a',)
		只含有单个数据的元组，要加逗号
总结
1
2
3
4
5
6
7
8
9
10
11
12
13
14
字符串、列表、元组  都是有顺序的一个数据集，也就是有序的序列
序列就是有顺序的数据集。字符串 列表 元组都是序列。
可变数据：  列表 （可变而的是列表中的数据，而不是这个对象）
不可变数据：  数、字符串、元组
可变不可变性质:不可变的是类型其中的数据
不可变数据对象，不可变的是指向关系，不是这个变量名
不可变的变量，变量在变的时候，重新给了新的指向关系，原来的不可变指向关系被抛弃了！
可变的变量，直接就能变指向关系

iterable
	可迭代的对象
		含有数据是一个集合
		数据前后可以互相找到
有序的序列就是可迭代的对象，如字符串，列表和元组。
序列
1
2
3
序列包含：字符串，元组，列表
序列支持索引和切片
序列是可迭代的对象
变量的本质
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
变量本质：
	变量不需要先定义(不需要声明大小类型)，可以直接使用，直接赋值a = 1
	变量可以重复赋值，哪怕更换类型
	同时可以给多个变量赋值
	命名风格，不要和模块名，常用函数 print，不能用数字开头，字母，数字，下划线，在python3，中文也可以做变量名
	__num__ 特殊的python内置变量
	不支持自增和自减
	引用计数： 就是针对一些不可变数据
    变量的内存分配方式
		变量在创建的时候，首先不会直接开辟空间，会先去查找，已有的空间
		如果有这个数据了，那么他不会创建新的，而是利用已有的
		del语句可以删除一个变量名，但是不会释放变量数据占据的空间
		del语句还把引用计数减1了，数据的空间只有在引用计数真正为0的时候才会释放
			python中的del语句释放数据内存? x
		查看变量的内存地址：id(变量名)
		import sys sys.getrefcount()  查看变量的引用计数
		注意：
			python解释器有没有在用
			赋值语句是否是单独创建，还是借用别人
引用计数
1
2
3
4
5
6
7
引用计数：
	常见变量会使用引用计数的方式分配内存，
	一个变量创建的时候，不会去直接创建一个新的地址，先去查找已有的(不可变数据：元组，字符串，整数)
	del 引用计数减一
	当一个对象真正最后引用计数为0的时候，才会被释放，延迟性
	del切断了变量名和具体数据的内存地址的连接，该变量所使用的数据的引用计数减去1
使用引用计数的原因：定义变量开辟空间，变量多，占用多，值相同的内存空间，相互共享，而不用创建
运算表达式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
算数表达式:
	+ - * /   //  %  ** 
逻辑表达式 返回值类型是Bool
	a = 1	非空非0为真
    b = 0  0或空为假
    not a 逻辑非
    a and b  逻辑与
    a or b 逻辑或
    a is b  a和b是不是同一个对象
    a is not b  a和b不是同一个对象
    
	is不光是判断值相同，还要判断是否是同一地址
	与：and -> False 真真为真，真假为假，假假为假，只要有假则为假
	或：or -> True真真为真，真假为真，假假为假，只要有真则为真
关系表达式 如果不是数字来判断，那么判断的就是阿斯克码
	表达式          汉译              返回值类型
    a==b         a,b是否值相等            bool
    a!=b         a,b是否值不相等          bool
    a<>b         a,b是否值不相等          bool
    a>b          a是否大于b               bool
    a<b          a是否小于b               bool
    a>=b          a是否大于等于b          bool
    a<=b          a是否小于等于b          bool
    
    小写字母a的十进制 ascii：97
    大写字母A的十进制 ascii：65
位运算：
	表达式           汉译               操作解释
    ~a               按位取反             -(a+1)
    a<<n             左移n位              -
    a>>n             右移n位              -
    a&b              a和b按位与           11->1  00->0  01->0(都是1时才得1)
    a|b              a和b按位或           01->1  11->1  00->0(只要有1就得1)
    a^b              a和b按位异或         01->1  11->0  00->0(相同得0，不同得1)
	
    计算机中存储的都是二进制
	所有的运算，到最后，都是二进制的补码在运算，补码才是真正在计算机里存储的，
	符号位参与运算，计算完成的结果也是补码
    原码，反码，补码
    正数的原码，反码，补码都是本身
    负数：
        原码：1000 0001 最高位是符号位
        反码：1111 1110 符号位不变，其余各位取反
        补码：1111 1111 -1 补码是反码加一
	所有的运算都是 补码在做运算
    	   1              -1
    原码  0000 0001     1000 0001 
    反码  0000 0001     1111 1110  负数的反码 符号为不变，其余各位取反
    补码  0000 0001     1111 1111  反码+1
    
    对补码在求一次补码即可求出原码
    
    a >> n 向右移动  位移的位置包含起点，其实就位移了一位。类似切片中的步长，步长计算也包含起点
    ------------------------
    a & b  a和b按位与 ，位上的值，只要有0，结果为0
    a | b   a和b按位或，位上的值，只要有1，结果为1
    a ^ b  a和b按位异或，只要值不同，结果才为1
    
    所有的运算，都是补码在运算！！！
条件分支语句
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
if …. else… 语句中 如果有一个条件满足，其他不会执行
else条件也可以没有,elif条件也可以没有
elif 可以 继续细分条件

while条件语句返回值为True时，执行语句才会被执行

for 访问可迭代的对象
	for var in 可迭代的对象(str,list,tuple):
		一次次的从里面取一个值
break
	条件满足时，直接跳出循环
continue
	条件满足时，只是跳过本次循环
	循环搭配else语句来使用，这里else语句中的内容会在循环正常结束之后来执行

#for var in seq:
    #遍历一个序列(前后数据间有顺序关系)，然后去其中一次次的拿取值
    #for循环一般不用来实现死循环
    #for次数一般由我们的数据长度来决定
    #for循环每次会向后遍历
    #for循环的死循环 需要构建环形或者无限延申的数据
    
    #from itertools import cycle
    #cycle([1,2,3]) -> 圈
python3和python2区别
1
2
3
4
5
6
7
8
9
10
11
12
python3:
	print() 	%s接收到的可以是任意的数据类型
				%d 用来输出整数
				%f 用来输出浮点数，%.100f 控制输出的精度
	input()	所有接收到的都是字符串
	range() 抽象,不会生成数据，只有在使用的时候才会生成数据
python2:
    print()
    input()  有效的数据，代码输入进来也是有效的，缓冲区溢出攻击
    raw_input() 所有接收到的都是字符串
    range() 具象的，会立即创建出实际的数据，很耗费内存
	xrange() 抽象的，不会生成数据，只有在使用的时候才会生成数据
深浅拷贝
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
拷贝： 可变数据对象的指针被共享了(引用计数)，所以需要我们引入拷贝
创建变量的时候，我们希望的只是值相等，而不是互相影响
a[:] 这是返回了一个新的列表，只是值和原先的a是一样的
浅拷贝的方法：
	切片拷贝，只能是复制浅层的数据对象，返回一个新的地址中的数据，内层的数据并没有实现拷贝
	a=[1,2,3,4]
    b=a[:]
    import copy
    b=copy.copy(a)
深拷贝：
	深拷贝可以实现地址不同
    深拷贝，拷贝的都是列表中的指向关系，对应列表中的数据还是使用引用计数的
    import copy
    a = [1,2,3,['a','b']]
    b = copy.deepcopy(a)
作业：使用切片实现深拷贝
1
2
3
4
5
6
7
8
9
10
11
12
a=[1,2,[1,2,3,[1,2,[1,2],3]]]
b=a[:]
b[-1]=a[-1][:]  #[1,2,3,[1,2,[1,2],3]]
b[-1][-1]=a[-1][-1][:]   #[1,2,[1,2],3]
b[-1][-1][2]=a[-1][-1][2][:]

print("a:",a)
print("b:",b)
print("------------")
b[-1][-1][2][-1]='abc'
print("a:",a)
print("b:",b)
作业：求出mylist中每一个值
1
2
3
4
5
6
7
8
9
10
11
12
mylist = [1,2,3,[1,2,('a','b')],'c','def']
for var in mylist:
    if type(var) == type([1]):#print('----',var)#当前满足列表
        for var1 in var:
            if type(var1) == type((1,)):#var1此时是元组
                for var2 in var1:
                    print(var2)
            else:
                print(var1)
    else:
        print(var)
print('---------------------')
作业：两数交换有几种办法
1
2
3
4
5
6
7
8
两数交换有几种办法？分别列举
a=1
b=2
最笨的方法：x=a a=b b=x
方法一：a,b=b,a
方法二：a=a+b  a=a-b b=a-b
方法三：a=a*b  b=a/b a=a/b
方法四：a=a|b  b=a^b a=a^b
作业：实现99乘法表
1
2
3
4
5
6
7
8
for i in range(1,10):
	for j in range(1,i+1):
		if i>j:
			print("%s x %s = %s   "%(j,i,i*j),end="")
		else:
			print()
		j+=1
	i+=1
作业：机器学习代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import pickle
import os
if os.path.exists("data.pkl"):
	f=open("data.pkl","rb")
	mydict=pickle.load(f)
	# print("数据已存在！")
	f.close()
else:
	mydict={'hello':'hello'}
	f=open("data.pkl","wb")
	pickle.dump(mydict,f)
	# print("新建数据库信息！")
	f.close()

while True:
	ques=input("请输入困扰你的问题： ")
	if ques != "quit":
		if ques in mydict:
			print(mydict[ques])
		else:
			ans=input("你教教俺吧。。。")
			if ans:
				mydict[ques]=ans
	else:
		break	

f=open("data.pkl","wb")
pickle.dump(mydict,f)
f.close()
作业：实现计算器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
cm = input("请输入你要计算的表达式:")
index = 0
for var in cm:
    if var in {'+','-','*','/'}:
        l_num,r_num = float(cm[:index]),float(cm[index+1:])
        #取出左边的数据,并且转换成浮点型
        #取出右边的数据,并且转换成浮点型
        break
    index += 1 #index是操作符在输入表达式的里面
cau = {
    '+': l_num + r_num,
    '-': l_num - r_num,
    "*": l_num * r_num,
} #if条件远远不如字典判断快
if r_num != 0:
    cau['/'] = l_num / r_num
print('result:',cau.get(cm[index]))
#get方法在key值不存在的时候，不会爆错
#cm[index]: 获取到了操作符
#
********************************************************************************

expr = input('请输入一个运算表达式:')
#'    2  |*| 0'
index = 0 #用来查找表达式中 + - * /符号的位置
for var in expr: #定位表达式中操作符的位置
    if var in {'+','-','*','/'}:
        print("[+] 操作符位置:%d" % index)
        print("[+] 操作符:%s" % var)
        break # 找到了操作符，那么就跳出循环即可
        #%d 可以整形转义输出
        #%s 转移输出字符串
    index += 1
#找到左右两个数字
#通过切片访问到字符串中的所有两个数字
l_num = float(expr[:index]) #左边的操作数
r_num = float(expr[index+1:]) #右边的操作数 不能是0
#除法 被除数不能为0
oper = expr[index] #找到了操作符

res = {
    '+': l_num + r_num,
    '-': l_num - r_num,
    '*': l_num * r_num,
}
if r_num != 0: #当第二个操作不为0的时候 才支持除法
    res['/'] = l_num / r_num

print('你的结果是: %s' % res.get(oper))
#get获取字典中不存在key值不会报错，只会返回None
    # %d 只能支持数字(整数)
    # %s 随意一些，支持所有的类型
字典
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
创建方法：
	1、语法大括号包裹：创建字典 = {key:value}
	2、工厂方法创建字典：res = dict(([1, 2],['a', 'b']))
    3、内建方法：dict.fromkeys( [1,2,3,4,5], 'a' )
	   批量创建key值，无法单独为每个key分配具体的value
字典的key是绝对唯一的，不可变的数据才可以做key值
字典的value可以重复，可以是任意的数据类型
字典来自于hash表构成的，hash的检索特别块，hash之后，key值对应的hash值会指向一个具体value地址，也就是为啥我们通过key值访问value很快，就是因为hash表
hash算法处理后的数据，不管之前有多么接近，之后绝对是唯一的，所以需要，key值是一个不能变的
字典也算的上是个无序的数据类型，在python3.6 字典有序了

字典： { key: value  }
	key：
		1：hash运算key创建出hash表
		2：hash表的查询速度很快
		3：字典，他是不可以做索引，切片
		4：key值必须是一个不可变数据对象：数字，字符串，元组，
		5：key值必须是一个唯一的
	value：
		1：可以存储不同的数据类型
		2：多个key同时对应一个value
		{1:'a' , 2: 'a'}
访问字典：
	mydict[key]
	mydict.keys()	获取字典中所有的key值
	mydict.values()	获取字典中所有的value值
更新字典：
	mydict[key]=value
	如果key存在的话，就更新value，如果key不存在的话就创建一个先的key:value的值
删除字典：
	del mydict[key]	直接删除key值
    mydict.pop()  在删除key值得过程中，还会把value值返回
    mydict.clear() 清空字典
    del mydict  直接删除字典
mydict.get(key)  此命令在key存在的时候返回对应的value，若key不存在，返回空，不报错
集合
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
可变集合：myset=set()
不可变集合：myset=frozenset()

做爬虫的时候使用集合保存爬取的URL，可以处理重复的连接
集合中的数据没有前后关系，而且是无序的，不能使用for循环来遍历
集合的特性：
	1、集合是无序的，无法使用for来遍历,不可以索引和切片
    2、集合的数据是去重的
    3、集合不能存储可变数据对象，因为可变数据对象无法进行hash运算
    4、集合中的所有数据元素都要经过hash运算，会维护hash表
    5、一个空集合只能通过set()的方式来创建
    	myset={}这个创建的是一个字典
    6、没有value的字典就是集合
    7、普通集合是可变的，不可变集合是frozenset(序列)
更新集合：
	set.add(不可变数据类型)
    	如果这个类型是不可变序列，这个序列会原样加进集合中
    set.update(数据集str,list,tuple,dict,set)
    	数据集将拆分成单个的元素，去掉重复的，然后加入到集合中
        数据集不允许含有可变数据对象
        数据集：str,list,tuple,dict(key值作为集合中的数据)，set,frozenset
可变集合---删除集合
	set.remove(集合中的数据元素) 删除后没有任何返回
    set.pop() 不接收任何参数，随机删除，并返回被删除的元素
    del myset  直接删除这个变量
可变集合和不可变集合都只能通过for循环迭代访问
可用in 和 not in 判断元素是否在集合中
可以用in和not in去获取一个数据集中是否有某个元素
	字符串，元组，列表，字典，集合
    in是去判断数据库里读取的数据集
更新集合：
	myset.add(seq) 直接修改集合本身，会保留和维护数据的形态到集合中
    myset.update(seq) 直接修改集合本身，会将数据拆分去重后加入到集合中
    	并且update不接收一个不可拆分的数据，比如整数
        update也可以接收一个列表
删除集合:
    myset.pop()  随机删除并返回删除的值
    myset.remove(obj) 在集合中删除obj,删除一个不存在的值会报错
    myset.discard(obj) 在集合中删除obj,删除一个不存在的值不会报错
    del  myset  直接把集合删除了，集合的引用计数减去1
集合的运算
	a的元素b都有
        子集：a.issubset(b)  a是b的子集
        超集：b.isuperset(b)  b是a的超集
        交集(&)：a和b中共同含有的数据，去重后返回的新的集合就a和b的交集
        并集(|)：a和b两个集合所有元素放到一起，去掉重复返回的新的集合就是a和b的交集
        差集(-)：a-b 从a中去掉a和b共有的，也就是b中有的a都不要了，返回一个新德集合
        对称差分(^)：找出两个集合中各自单独有的数据，也就是a和b的交集减去并集的数据
系统内置函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
enumerate(iter):接受一个可迭代的对象作为参数，返回一个enumerate对象，
        也是一个迭代器，该对象生成由iter每个元素的index值和item值
len(seq):返回seq长度
max(iter,key=None) or max(arg0,arg1...key=None):
    返回iter或(arg0,arg1)中的最大值，如果指定了key，
    这个key必须是可以传给sort()方法的，用于比较回调的函数
min(iter,key=None) or min(arg0,arg1...key=None):
    返回iter或(arg0,arg1)中的最大值，如果指定了key，
    这个key必须是可以传给sort()方法的，用于比较回调的函数
    >>> max('a123','b123',key=lambda x:x[2])
    >>> 'a123'
max函数之后的lambda表达式，在指定出元素之后，
    会按照你选择的元素来排序，x[2]就是x的第二个元素进行排序
reversed(seq):接受一个序列作为参数，返回一个以逆序访问的迭代器
sorted(iter,cmp=None,key=None):
    接受一个可迭代的对象作为参数，返回一个有序的列表，可选参数是一个排序方式
sum(seq,init=0):返回seq和可选参数init的总和
zip(it0,it1,...itN):返回一个列表，用法如下：
    可以将对应的序列 对应的索引位置 拼接成一个二元组或者多元组
	如果序列长度不一，以短的为主。
    zip函数返回的是一个抽象的数据，保证内存安全，实现了迭代器(可以延迟生产数据)
    
    >>> a=zip('123','abcdef','ABC')
    <zip object at 0x000001E28964C848>
    >>> for i in a:
        ...    print(i)
        ...
        ('1', 'a','A')
        ('2', 'b','B')
        ('3', 'c','C')
map(func,seq):map函数第一个参数可以是一个函数对象，第二个是一个序列
    map函数可以传入的函数依次作用在序列的每一个元素上。
    实例：
    >>> def ys(x):
        ...     return x*x+1
    >>> mylist=[1,2,3,4,5]
    >>> yes=map(ys,mylist)
    >>> for i in yes:
        ...     print(i)
        2
        5
        10
        17
        26
reduce函数(导入reduce函数 from functools import reduce)
    用法：reduce把一个函数作用在一个序列[x1,x2,x3...]上，这个函数必须接收两个参数
    reduce把结果继续和序列的下一个元素左累积计算，效果如下：
    >>> def add(x,y):
        ...     return x+y
    >>> from functools import reduce
    >>> mylist=[1,2,3,4,5]
    >>> reduce(add,mylist)
    15
    >>> def cf(x,y):
        ...     return x*y+1
    >>> reduce(cf,mylist)
    120
eval(字符串对象)  -> 一般不要用
    会把无意义的字符串变成了合法的表达式
    表达式 一个有效的可以得出结果的式子
repr(表达式)  
	将一个表达式变成无意义的字符串
str内置函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
字符串内建函数--大小写转换函数
    string.lower():字母大写转换为小写
    string.upper():字母小写转换为大写
    string.swapcase():字母大写转换为小写,小写转大写
    string.title():将语句中所有单词的首字母大写
    string.capitalize():将语句中首字母大写，其他小写
字符串内建函数--搜索函数
    string.find(str,[start=0,stop=len(string)])
        计算string中出现str的第一个字母的索引，如果没有出现，则返回-1
    string.index(str,[start=0,stop=len(string)])
        计算string中出现str的第一个字母的索引，如果没有出现，出现异常
    string.count(str,[start=0,stop=len(string)]):
        计算str在string中出现的次数
    string.endswith(str,[start=0,stop=len(string)])
        检查sring是否是以str结尾，如果是返回True，反之返回False
字符串内建函数--替换函数
    string.replace(str1,str2,[num=string.count(str1)])
        将str1替换为str2，num为替换次数，默认次数为str1出现的次数
    string.strip(chr):在string的开头和结尾删除chr，当chr为空时，默认删除空白符(\r,\n,\t," ")
    string.rstrip():删除string字符串末尾的空格，或者换行符号
    string.lstrip():删除string字符串开头的空格，或者换行符号
字符串内建函数--判断函数
    string.isdigit():如果string只包含数字，则返回True，否则返回False
    string.islower():如果字符串中的字母都是小写则返回True，否则返回False
    string.isupper():如果字符串中的字母都是大写则返回True，否则返回False
    string.isspace():字符串中只包含空白字符，返回True，否则返回False
列表内置函数
1
2
3
4
5
6
7
8
list.append(obj):在尾部追加obj
list.count():返回一个对象在列表中出现的次数
list.extend(seq):把序列seq中的内容添加到列表中
>>> mylist.extend('abc')
>>> [1, 2, 3, 'a', 'b', 'c']
list.insert(index,obj):在索引index的位置插入obj，原位置数据向后移动
list.pop(index):删除并返回index位置的数据对象，默认是最后一个对象
list.reverse():反转列表
元组内置函数
1
2
tuple.index(obj,beg=0,end=len(string)):检查obj是否包含在tuple中
tuple.count(obj):返回obj出现的次数
推导式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
推导式：
	一种方便的结合for循环进行数据处理的方式
	for循环 -> 序列中一个个的取值
列表推导式
	[ 表达式 for var in iterable if 过滤条件 ]
	1：for循环从iterable取值
	2：取到的值首先要经过if条件判断
	3：判断条件成立的数据，放到表达式运算，运算后的结果，作为新列表中的值
集合推导式
	{ key for var in iterable if 过滤条件 }

字典推导式
	{ key:value for var in iterable if 过滤条件 }

元组推导式 == 迭代器
	( key for var in iterable if 过滤条件 )  -> iter
    
列表表达式： [ 表达式 for value in 序列 if 过滤条件 ]
元组表达式： ( 表达式 for value in 序列 if 过滤条件 )
    所有从这个for循环出来的每一个数据首先会经过if条件过滤，然后执行前面的表达式，
    最后重新返回成一个新的列表，过滤条件可有可无
    >>> mylist=[1,2,3,4]
    >>> [var*var for var in mylist if var!=3]
    [1, 4, 16]
    >>> (var*var for var in mylist if var!=3)
    <generator object <genexpr> at 0x00000238D160B3B8>
    >>> my_tuple=(var*var for var in mylist if var!=3)
    >>> for i in my_tuple:
    ...     print(i)
    ...
    1
    4
    16
    >>> my_tuple=(var*var for var in mylist if var!=3)
    >>> my_tuple.__next__()
    1
    >>> my_tuple.__next__()
    4
    >>> my_tuple.__next__()
    16
    >>> my_tuple.__next__()
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    StopIteration

    通过列表推导式就可以把我们含有大小写的列表改成全部大写的列表
    我们生成出所有经过表达式的一个结果序列，并且是列表类型的
	元组表达式就是生成器，只有在使用到的时候才生成，比较节约内存

字典推导式：
    和列表类似，只不过需要两个值存在来维护字典的键值对形式
    {key:value for key in 序列 if 过滤条件}

    enumerate(obj):这个函数会返回两个值，一个是序列的下标，一个是下标对应的值
    >>> mylist=['a','b','c','d']
    >>> mydict={key:value for key,value in enumerate(mylist)}
    >>> mydict
    {0: 'a', 1: 'b', 2: 'c', 3: 'd'}
    
mydict = {'初心':{'money':100000,'sex':'male'},'Infor':{'Money':110000,'sex':'male'}}
#list(mydict[var].keys())[0]
newdict = {var:{list(mydict[var].keys())[0]:mydict[var][list(mydict[var].keys())[0]]+1000} for var in mydict}
print(newdict)

集合推到式：
    集合推导式跟列表推导式非常相似，唯一的区别在于用{}代替[]
    {表达式 for value in 序列 if 过滤条件}
    >>> mylist
    ['a', 'b', 'c', 'd']
    >>> myset={var*2 for var in mylist}
    >>> myset
    {'aa', 'bb', 'cc', 'dd'}

推到式：表达式  for var in 序列 if 过滤
作业：2万以下的 加工资
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
salary_list = [13000,12700,15000,14000,25000,16000,18000,22000,32000]
#2万以下的 加工资
#加1000
new_list = []
for var in salary_list:
    if var <= 20000:
        var+=1000
    new_list.append(var)
print(new_list)

res = [ var + 1000 for var in salary_list if var <= 20000 ]
salary_list[:len(res)] = res
print(res)
#1: for循环取值
#2: 经过if条件判断
#3: 放到最前面，作为新列表的值
    #if...else  if如果不满足，那么执行else
    #for...else  可以循环正常结束的时候，for...else执行

#把新的列表替换原来的列表元素

**********************************************************************

mylist = [13000,15000,15000,17000,20000,14500,23400,27000]
        #15000 + 2000 - > 17000
        #这个17000和后面的17000重复了，所以会替换多次，一个15000到最后多添加了好几次呢
def replace(old,new):
    #不要因为数据相同而重复替换 要避免这个
    #直接修改mylist 这个变量本身
    global mylist #使用全局变量mylist及index_list
    global index_list
    for _index,var in enumerate(mylist):
        if var == old and _index not in index_list: #如果这个索引还没出现过，那么就替换
            print('当前替换的是:',mylist[_index])
            mylist[_index] = new
            index_list.append(_index) #替换完成，记录一下
    print("--------------") #函数之行一次之后打印一次横线
        #函数没有返回值，那么就返回None

[replace(var,var+2000) for var in mylist if var < 20000]
    #var : old
    #var + 2000 : new
print('new:',mylist)
作业：做一个自己的帮助文档
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
def func():
    '''
        这就是我的帮助文档
    '''
    #__doc__  可以调取帮助文档
help(func)
print(func.__doc__)
res = dir(str)
help_dict = {}
#帮助文档的列表
for func in res: #提取每个函数
    if '__' in func: #过滤下划线函数
        continue
    help_dict[func] = func.__doc__ #把帮助文档追加到列表
        #有则修改，没有则增加
    #key: func 函数名字符串
    #value: func.__doc__ 帮助文档
for key in help_dict:
    print(key) #首先打印函数名
    print(help_dict[key]) #在打印帮助文档
    print('-------------------------')
#Web GUI
***************************************************************************************
while True:
	print('退出请输入: q/Q\n')
	user_req = input('请输入查询序列类型(str/list/tuple/dict/set):\n')
	print()
	if user_req == 'q' or user_req == 'Q':
		break
	else:
		try:
			res = dir(eval(user_req))
			print(res)
			print()
			search_req = input('请输入查询函数:\n')
			print()
			try:
				help(eval(user_req + '.' + search_req))
			except AttributeError as first_reason:
				print('请重新输入!!!The reason: ',str(first_reason))
		except NameError as second_reason:
			print("错啦,重新输入!!!The reason: ",str(second_reason))
作业：每个爷们加1000工资
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
mydict = {
    'KM':        {'sex':'male',  '工作':'Star', 'money':13000,},
    'Charles':   {'money':13000, '性别':'male',  'like':'DJ'},
    'Mark Smith':{'salary':13000, 'sex':'male',  'job':'Rap'},
    'QQ':        {'money':15000, '性别':'female','job':'Dancer'}
}
#dict keys values dict[key] for key in dict
#推导式实现一下，每个爷们加个1000
#job要留下来,money要留下来
def func(var):
    var = list(var)
    if 'male' in var:#先判断是否是个男的
        for _index,value in enumerate(var): #判断是不是个数字
            if type(value) == int:
                var[_index] = value + 1000 #数个数字 加1000
    return tuple(var)

new_dict = { key:dict( zip( list( mydict[key].keys() ), func( mydict[key].values() ) ) ) for key in mydict }
#只有工资对应的value值是一个整数 int
for key in new_dict:
    print(key,':',new_dict[key])
print("==================")
作业：四色五入
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
a = 123.9443712837819
float_index = 2 #我就要2位小数
int_part = str(a).split('.')[0] #123 整数部分 str
float_part = str(a).split('.')[-1] #90182039 小数部分 str
print("原有数据:",a)
print('整数部分:',int_part)
print('小数部分:',float_part)
#字符串判断整数 直接对比值大小
#字符串判断的是字母 那就是对比ascii码 a 97 A 65
if len(float_part) <= float_index: #判断小数长度与精度位数的大小
    print("处理完成之后的小数:",a)
else:
    if int(float_part[float_index]) >= 5: #获取小数部分最后一位
        print('小数部分最后一位:',float_part[float_index])
        print('扔掉最后一位的结果:',float_part[:float_index])
        float_part = str( int(float_part[:float_index]) + 1 )
        print('最后的小数部分:',float_part)
    else: #如果说位数精度的数字小于5，不满足上位的条件，那么直接把后面的位省去
        print('小数部分最后一位:',float_part[float_index])
        print('扔掉最后一位的结果:',float_part[:float_index])
        float_part = str( int(float_part[:float_index]) )
        print('最后的小数部分:',float_part)
    res = float('.'.join( [int_part,float_part] ))
    #res = float(int_part + '.' + float_part)
    print('整数和小数拼接:',res)
def func(var,f_index):
    '''
        func(var,f_index) -> float
        这个函数用来做四舍五入的精度处理
        参数：
            var是你传入的小数
            f_index是你需要的精度
        返回值：
            处理后的小数
    '''
    int_part = str(var).split('.')[0] #123 整数部分 str
    float_part = str(var).split('.')[-1] #90182039 小数部分 st
    if len(float_part) <= f_index: #判断小数长度与精度位数的大小
        float_part = float_part.ljust(f_index,'0') #需要补位的长度
    else: #如果需要来维护精度，本身的浮点数长度大于了精度要求
        if int(float_part[f_index]) >= 5: #获取小数部分最后一位
            float_part = str( int(float_part[:f_index]) + 1 )
        else: #如果说位数精度的数字小于5，不满足上位的条件，那么直接把后面的位省去
            float_part = str( int(float_part[:f_index]) )
    res = float('.'.join( [int_part,float_part] ))
    #res = float(int_part + '.' + float_part)
    return res
res = func(1.2,5) #->1.124
print(res)
作业：人生
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
# seq 序列: str list tuple set dict
# iterable 可迭代的对象: str list tuple set dict 文件 数据库句柄 数据库返回结果集 生成器迭代器
import random
#baby -> 小孩
#babe、sweet、my cup of tea -> 宝贝
    #you are my cup of tea
#random choice -> a random element from a non-empty sequence.
#choice(seq) method of random.Random instance
    #Choose a random element from a non-empty sequence.
    #从一个不为空的序列中去取一个值
te = {  #个人信息
    'name':'human',
    'age':18,
    'job':'tea',
    'like':'study',
    'babe':{},
        #保存你的娃
        #娃的名字，娃的性别
}
sex_list = ['male','female'] #人的性别
mind_list = ['不好','还行','非常好',' '] #情绪的列表，为了可以随机抽样选择
things_list = ['normal','dangours','love','gay','moeny','babe']
active_dict = { #当你情绪不一样的时候，所要做的事情
    '不好': 'play computer', #可以这样创建，但是后面的表达式 会实际的运行的
    '还行': 'eat',
    '非常好' : '不上课了 我要到外面的世界',
    }
#字典不具体的来保存行为，他只是来保存我们要做的事情
    #这个事情一定不要在定义字典的时候来实现
#赋值语句是没有返回值的，直接修改的是对象本身
for var in range(365 * 80):
    mind = random.choice(mind_list) #随机抽取今天的情绪
    things = random.choice(things_list) #随机抽取时间
    active = active_dict.get(mind) #执行今天这个心情我要做的事情
    if things == 'babe':
        print('今天是第%d天,今天生了!' % var)
        print('         *         ')
        print('        ***        ')
        print('       ******     ')
        print('         **       ')
        print('         **       ')
        babe_name = 'babe' + str(var) #宝宝名字命名
        babe_sex = random.choice(sex_list)
        te['babe'][babe_name] = babe_sex
    elif things == 'dangours':
        print('这是第%d天,今天GG了' % var)
        break
    else: #其他时候都是平平淡淡
        if active:
            te['like'] = active
        print('今天是第%d天,今天我遇到了%s: 今天的心情%s, 我要做的事情%s' % (var, things, mind, te['like'] ))
else:
    print('完美结束')

print('----------人生总结----------')
for key in te:
    print('%s:%s' % (key,te[key]))
    if key == 'babe':
        print("你还有孩子，在下面-------")
        for babe_name in te[key]: #拿到我的孩子列表
            print('%s:%s' % (babe_name,te[key][babe_name]))

#'rich':富有
#'handsome':帅气
坚持原创技术分享，您的支持将鼓励我继续创作！