本文共 7392 字，大约阅读时间需要 24 分钟。
一、数字
数字类型包含整型、浮点型，还包含不太常用的长整型、复数。
二、字符串
定义：在单引号\双引号\三引号内，由一串字符组成
| 1 | msg = 'hello world' |
1、切片
| 1 2 3 4 | print (msg[ 1 : 8 ]) #从下标为1的字符开始取，顾头不顾尾，所以取到第七个字符，所以得到ello wo，空格也是一个字符 print (msg[ 1 : 8 : 2 ]) #从下标为1的字符开始取，顾头不顾尾，所以取到第七个字符，步长为2，取一个跳过一个，得到el o print (msg[ 0 ]) #取出下标为0的字符、就是第一个字符，得到h print (msg[ - 1 ]) #取出最后一个字符，得到d |
2、长度
| 1 | print ( len (msg)) #变量msg的字符串长度，得到11 |
3、成员运算in和not in，看所取得字符是否在变量定义的字符串里
| 1 | print ( 'llo' in msg) #‘llo’在变量定义的字符串里，所以返回True |
4、移除空白strip
| 1 2 3 4 5 6 7 | name = '**********hello***********' print (name.strip( '*' )) #去掉hello两边的* print (name.lstrip( '*' )) #去掉hello左边的* print (name.rstrip( '*' )) #去掉hello右边的* #和用户交互常用的情况如下 name = input ( 'user: ' ).strip() #对用户输入的字符串去掉两边的空格 print (name) |
5、切分
| 1 2 3 4 | info = 'root:x:0:0::/root:/bin/bash' res = info.split( ':' ) #以冒号为分隔符对字符串进行分割，分割后会变成列表的形式 res = info.split( ':' , 1 ) #以冒号为分隔符对字符串进行分割，并指定分割最大次数为1，方便取出第一个冒号前的字符串 res = info.rsplit( ':' , 1 ) #从右进行切分，切分一次，结果是按照最后的冒号把字符串切为两部分 |
6、循环
| 1 2 | for i in range ( 0 , 5 , 2 ): #0到4之间，步长为2，所以得到结果0 2 4 print (i) |
7、lower,upper
| 1 2 | print ( 'AbcD' .lower()) #把字符串全部显示成小写，结果是abcd print ( 'aaa' .upper()) #把字符串全部显示成大写，结果是AAA |
8、startswith,endswith
| 1 2 3 4 | msg = 'tom is boy' print (msg.startswith( 'tom' )) #开头的是否是tom，返回True或者False,所以返回True print (msg.startswith( 't' )) #开头的是否是t，所以返回True print (msg.endswith( 'boy' )) #末尾的是否是boy,所以返回True |
9、join
| 1 2 | l = [ 'root' , 'x' , '0' , '0' ] ':' .join(l) #把列表l里的元素通过冒号合并成一个字符串， 列表l里的元素必须全是字符串，否则报错 |
10、replace
| 1 2 3 | msg = 'tom say my name is tom' msg = msg.replace( 'alex' , 'leader' , 1 ) #用leader替换tom，并且只替换一个 print (msg) |
11、isdigit判断是否是数字
| 1 2 3 4 5 6 | age = input ( '>>: ' ).strip() if age.isdigit(): #用户输入的是数字以后，将其转化成整型 age = int (age) else : print ( '必须输入数字' ) print (age, type (age)) |
三、列表
1、定义：[]内可以有多个任意类型的值，逗号分隔
| 1 | name = [ 'zhao' , 'qian' , 'sun' , 'li' ] |
2.方法append和extend，insert
| 1 2 3 4 5 | name.append( 'ni' ) #列表里添加元素ni l = [ 'song' , 'zhang' ] name.extend(l) #列表里添加多个元素 print (name) name.insert( 1 , 'wang' ) #插入元素wang，下标为1 |
3、方法index
| 1 | print (name.index( 'zhao' )) #显示元素zhao对应的下标 |
4、remove和pop
| 1 2 3 | name.remove( 'li' ) #删除元素li，但是拿不到取走的元素 print (name) name.pop() #删除并拿到结果，取走一个值 |
5、循环
| 1 2 | for item in name: print (item) |
6、clear
| 1 | name.clear() #清空列表 |
7、copy
| 1 2 | l = name.copy() #拷贝列表name，将结果作为变量l的值 print (l) |
8、count
| 1 | print (name.count( 'li' )) #统计元素li出现在列表里几次 |
9、reverse
| 1 | name.reverse() #将列表name元素倒向显示，结果为['li', 'sun', 'qian', 'zhao'] |
10、sort排序
| 1 2 3 4 5 | l = [ 1 , 10 , 4 , 11 , 2 ,] l.sort() #对列表里的元素排序 print (l) l.sort(reverse = True ) #对列表里的元素倒向排序 print (l) |
四、元组
1、与列表类型比，只不过[]换成()
存多个值，对比列表来说，元组不可变，主要是用来读
| 1 | age = ( 11 , 22 , 33 , 44 , 55 ) |
1、index
| 1 2 3 | print (age.index( 11 )) #取出元组里元素11对应得下标 print (age.index( 3333 )) # 元素不存在时报错ValueError: tuple.index(x): x not in tuple print (age[ 0 : 3 ]) #取出元组里元素下标为0,1,2的子元组 |
2、长度len
| 1 | print ( len (age)) #得到元组元素的个数 |
3、成员运算in和not in
| 1 | print ( 11 in age) #判断元素11是否在元组里 |
4、循环
| 1 2 | for item in age: print (item) |
5、count
| 1 | print (age.count( 33 )) #判断元素33出现的次数 |
6、实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | msg_dic = { 'apple' : 10 , 'tesla' : 100000 , 'mac' : 3000 , } goods = [] #购物车，准备一个空列表 while True : for k in msg_dic: print (k,msg_dic[k]) choice = input ( 'name: ' ).strip() if len (choice) = = 0 or choice not in msg_dic: #如果用户输入字符为空或者输入的不是指定的商品，就让用户重新输入 continue while True : num = input ( 'number: ' ).strip() if num.isdigit(): break goods.append((choice,msg_dic[choice], int (num))) #注意括号容易少写 print ( '购物车' ,goods) |
五、字典
1、定义：key必须是不可变类型（int，float，str，tuple），value可以是任意类型
| 1 | info = { 'name' : 'egon' , 'age' : 18 , 'sex' : 'male' } |
2、fromkeys
| 1 | info = {}.fromkeys([ 'name' , 'age' , 'sex' ], None ) #快速创建字典，前面列表的每个元素会和none组成字典的一个元素 |
3、修改字典的值
| 1 | info[ 'age' ] = 22 #指定key，等于一个值 |
4、长度len
| 1 | print ( len (info)) #判断字典的长度，即有几个元素 |
5、成员运算in和not in
| 1 | print ( 'name' in info) |
6、删除pop
| 1 2 | print (info.pop( 'name' )) #取出字典key为name的元素 print (info) # 看到元素为name的键值对已经删掉了 |
7、popitem和keys、values
| 1 2 3 4 5 6 | print (info.popitem()) #取出后面的键值对，结果是('sex', 'male') print (info.keys()) #取出字典里所有的key，结果是dict_keys(['name', 'age']) print ( list (info.keys())[ 1 ]) #取出字典里所有key的组合，转为列表，再根据下标取出对应得key，结果是age print (info.values()) #取出字典里所有的value，结果是dict_values(['egon', 18]) print ( list (info.values())[ 1 ]) #取出字典里所有value的组合，转为列表，再根据下标取出对应得value，结果是18 print ( list (info.items())[ 1 ]) #取出键值对，最后的结果是('age', 18) |
8、循环
| 1 2 3 | info = { 'name' : 'egon' , 'age' : 18 , 'sex' : 'male' } for k in info: #循环key，最后通过key取到values print (k,info[k]) |
9、有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中
| 1 2 3 4 5 6 7 8 | nums = [ 11 , 22 , 33 , 44 , 55 , 66 , 77 , 88 , 99 , 90 ] d = { 'k1' :[], 'k2' :[]} for num in nums: if num > 66 : d[ 'k1' ].append(num) if num < 66 : d[ 'k2' ].append(num) print (d) |
六、集合
1、定义和原则
集合：可以包含多个元素，用逗号分割
集合的元素遵循三个原则：
1：每个元素必须是不可变类型(可hash，可作为字典的key)
2: 没有重复的元素
3：无序
| 1 2 | pythons = { 'alex' , 'egon' , 'yuanhao' , 'tom' , 'jim' } linuxs = { 'tom' , 'sam' } |
2、长度
| 1 | print ( len (pythons)) #长度即是集合 python的元素个数，所以为5 |
3、成员运算in和not in
| 1 | print ( 'alex' in pythons) #判断alex是否在python集合中，所以结果为True |
4、交集
| 1 | print (pythons & linuxs) #同时在两个集合中的元素，所以结果是{'tom'} |
5、合集
| 1 | print (pythons | linuxs) #两个集合的所有元素，重复的显示一次，所以结果是{'tom', 'jim', 'egon', 'sam', 'alex', 'yuanhao'} |
6、差集
| 1 | print (pythons - linuxs) #python中的元素减去linuxs中的元素，剩下的结果是{'jim', 'yuanhao', 'egon', 'alex'} |
7、对称差集
| 1 | print (pythons ^ linuxs) #没有同时在两个集合中的元素，即所有元素减去交集的结果是{'egon', 'sam', 'jim', 'alex', 'yuanhao'} |
8、父集>,>=
| 1 2 3 | a = { 1 , 2 , 3 } b = { 1 , 2 } print (a> = b) #判断集合a是否包含集合b的元素，所以结果为True |
9、子集<,<=
| 1 | print (a< = b) #判断集合a是否被集合b包含，所以结果为False |
10、去重
| 1 2 | l = [ 'a' , 'b' , 1 , 'a' , 'a' ] print ( set (l)) #转为集合的形式，元素一样的显示一次，所以结果是{1, 'a', 'b'}，结果没有按照以前的顺序 |
11、循环
| 1 2 | for i in l: print (i) |
12、用之前的方法去重并保持顺序
| 1 2 3 4 5 | new = [] for i in l: if i not in new: new.append(i) print (new) |
13、借助集合实现去重并保持顺序
| 1 2 3 4 5 6 7 | new = [] s = set () for i in l: if i not in s: s.add(i) new.append(i) print (new) |
14、集合的其他用法
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | s1 = { 1 , 2 , 3 } s2 = { 1 , 2 } print (s1 - s2) #取得s1和s2的交集，不改变原来的集合的元素 print (s1.difference(s2)) #取s1和s2不同的地方，不改变原来的集合的元素 s1.difference_update(s2) #对s1赋值，改变了s1的元素，结果s1就成了{3} print (s2.pop()) #随机从集合s2中取走一个元素 s2.add( 'b' ) #给集合s2增加一个元素b s2.discard( 'b' ) #从集合中删除元素b，删除的元素不存在不会报错 s2.remove( 'b' ) #从集合中删除元素b，删除的元素不存在则报错 s1 = { 1 , 2 , 3 , 4 , 5 , 'a' } s2 = { 'b' , 'c' ,} print (s1.isdisjoint(s2)) #两个集合没有共同部分时，返回值为True s2.update({ 6 , 7 }) #集合s2增加元素6和7，一次添加多个元素,所以结果为{'c', 'b', 6, 7} print (s2) |
七、字符编码
1、存取文件不乱码的法则：用什么编码存的，就要用什么编码读
2、encode和decode
unicode-----encode----->gbk
gbk-------->decode----->unicode
3、解释器的字符编码
python3解释器默认使用的字符编码是utf-8
python2解释器默认使用的字符编码是ascii
4、
python2的str就是python3的bytes
python2的unicode就是python3的str
八、文件处理
1、打开文件读，python进程要访问文件，会向操作系统提交读请求，操作系统取到的数据交给进程，进程开辟内存空间存放数据，所以最后要关闭文件，回收操作系统的资源
| 1 2 3 4 5 | f = open (r 'C:\Users\song\Desktop\a.txt' , 'r' ,encoding = 'utf-8' ) #最前面的r表示保持字符的本意，不然'\'就需要转意 data = f.read() print (data) f.close() #文件关闭，回收操作系统的资源 print (f.readline(),end = '') #逐行读，文件大时，不能一次读所有数据，就需要逐行读了 |
2、为避免忘记关闭操作系统打开的文件，可以直接让程序关闭
| 1 | <span style = "font-size: 14px;" >with open ( 'a.txt' , 'r' ,encoding = 'utf-8' ) as f: < / span><br> |
3、写操作，每次执行都会清掉原来的数据，然后写入新的内容
| 1 2 3 4 | f = open (r 'C:\Users\song\Desktop\a.txt' , 'w' ,encoding = 'utf-8' ) f.write( '11111\n' ) f.write( '1111\n2222\n3333\n' ) #写入多行时，行尾用'\n'标识 f.close() |
本文转自 宋鹏超 51CTO博客，原文链接：http://blog.51cto.com/qidian510/2049727，如需转载请自行联系原作者