1. 数据类型
1.1 数字
数字的作用：与数字相关，例如：手机号、QQ号、身份证号等，用数字表示
数字分为：整数(int)、浮点数(float)、复数(了解)
例子：
age = 10 print(type(age)) salary = 5680.85 print(type(salary))
长整型和复数，了解即可
长整型：在pyhton2中使用，在python3已经废弃掉
复数：
x = 1 - 2j # 定义 print(x.real) # 获取实部 print(x.imag) # 获取虚部
整数分为：二进制、八进制、十进制、十六进制等
进制之间可以相互转换，例如：
age = 10 # age=int(10) print(bin(age)) # 十进制转化为二进制 print(oct(age)) # 十进制转化为八进制 print(hex(age)) # 十进制转化为十六进制
1.2 字符串
作用：定义名字、地址、国籍等描述性信息
定义：在单引号、双引号、三引号内由一串字符组成；字符串，本身存储一个值，由一串字符组成。
常用操作有：
移除空白
切分
长度
索引
切片
1.2.1 移除空白
移除空白的方法是strip，例如：
msg=' welcome to beijing ' print(msg.strip()) # 移除左右两侧空白 print(msg.rstrip()) # 移除右侧空白 print(msg.lstrip()) # 移除左侧空白
运行结果：
welcome to beijing
welcome to beijing
welcome to beijing
移除指定字符，比如移除指定字符’*’，例如：
msg='******python******' print(msg.strip('*')) print(msg.lstrip('*')) print(msg.rstrip('*'))
运行结果：
python python****** ******python
1.2.2 切分
字符串切分，通过制定切分字符，进行切分，切分的结果是一个列表，例如：
user_info='root:x:0:0::/root:/bin/bash' user_list=user_info.split(':') print(user_list)
运行结果：
['root', 'x', '0', '0', '', '/root', '/bin/bash']
指定切分次数进行字符串切分，例如：
cmd_info='get|sys.log|error' cmd_list=cmd_info.split('|',1) print(cmd_list)
运行结果：
['get', 'sys.log|error']
字符串默认切分分割符空格，例如：
msg='my name is jack '
运行结果：
['my', 'name', 'is', 'jack']
1.2.3长度
统计字符串长度，实际就是统计字符的个数，例如：
msg='hello world' print(msg.__len__()) # 属于内置方法 print(len(msg)) # 等价于msg.__len__()
1.2.4 切片
切片，跟下标有关，顾头不顾尾的操作，例如：
msg = 'hello world' print(msg[1:4]) print(msg[:4]) print(msg[4:]) print(msg[:-1]) print(msg[:]) print(msg[2:7:2])
执行结果：
ell
hell
o world
hello worl
hello world
low
1.2.5 其他操作
1.2.5.1 endswith startswith
startswith 以…开头，判断的结果是True、False
endswith 以…结尾，判断的结果是True、False
例如：
name='alex_SB' print(name.endswith('SB')) # 以SB开头，判断成功，显示True print(name.startswith('alex')) # 以alex结果，判断成功，显示True
1.2.5.2 replace
replace字符串的替换，例如：
name='alex say :i have one tesla,my name is alex' print(name.replace('alex','SB',1)) # 指定替换次数
1.2.5.3 format
字符串本身提供字符串格式的方法format，例如：
print('{} {} {}'.format('jack',58,'male')) print('{0} {1} {0}'.format('jack',58,'male')) print('NAME:{name} AGE:{age} SEX:{sex}'.format(age=58,sex='male',name='jack'))
运行结果：
jack 58 male jack 58 jack NAME:jack AGE:58 SEX:male
1.2.5.4 isdigit
判断字符串是否为数据，提供了三种方法isdigit、
num='123' print(num.isdigit())
利用isdigit判断是否为数字，进行程序的判断运行
jack_age=73 while True: age=input('>>: ').strip() if len(age) == 0:continue if age.isdigit(): age=int(age) print(age,type(age))
1.2.5.5 find index
name='jack say hello' print(name.find('o',1,3)) # 顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引 print(name.index('e',2,4)) # 同上,但是找不到会报错 print(name.count('e',1,3)) # 顾头不顾尾,如果不指定范围则查找所有
1.2.5.6 join
利用join，进行字符串的拼接，内容必须是字符串；否则会类别报错，
l=['jack','say','hello','world'] #类别内容必须都是字符串 print(':'.join(l)) tag=' ' print(tag.join(['jack','say','hello','world'])) #可迭代对象必须都是字符串
1.2.5.7 填充
利用center方法，进行填充，填充可以指定字符，默认填充字符是空格，例如：
name='jack' print(name.center(30)) print(name.center(30,'*')) print(name.ljust(30,'*')) print(name.rjust(30,'*')) print(name.zfill(30))
运行结果：
jack *************jack************* jack************************** **************************jack 00000000000000000000000000jack
1.2.5.8 expandtabs
指定tab键空格数量，默认的tab键是四个空格，例如：
name='jack hello' print(name) print(name.expandtabs(2))
1.2.5.9 大小写转换
name='JACK' print(name.lower()) # 大写转小写 name='jack' print(name.upper()) # 小写转大写
1.2.5.10 capitalize swapcase title
name='jack say' print(name.capitalize()) # 首字母大写 print(name.swapcase()) # 大小写翻转 msg='jack say hi' print(msg.title()) # 每个单词的首字母大写 name='jack123' print(name.isalnum()) # 字符串由字母和数字组成 name='jack' print(name.isalpha()) # 字符串只由字母组成
运行结果：
Jack say JACK SAY Jack Say Hi True True
1.2.5.11 判断数字
利用isdigit判断是否为数字，可以对Bytes、unicode进行数字判断：
num1=b'4' #Bytes num2=u'4' #unicode,python3中无需加u就是unicode num3='四' #中文数字 num4='Ⅳ' #罗马数字 print(num1.isdigit()) print(num2.isdigit()) print(num3.isdigit()) print(num4.isdigit())
运行结果：
True
True
False
False
利用isnumberic进行判断中文和罗马的数字
num1='四' #中文数字 num2='Ⅳ' #罗马数字 print(num1.isnumeric()) print(num2.isnumeric())
利用isdecimal进行判断unicode的数字
num1=u'4' #unicode,python3中无需加u就是unicode num2='四' #中文数字 num3='Ⅳ' #罗马数字 #isdecimal:对unicode的数字进行判断 print(num1.isdecimal()) # 结果True print(num2.isdecimal()) # 结果False print(num3.isdecimal()) # 结果False
结论：用isdigit基本满足对数字的判断
1.2.5.12 练习题
# 写代码,有如下变量,请按照要求实现每个功能 name = " aleX" # 1) 移除 name 变量对应的值两边的空格,并输出处理结果 print(name.strip()) # 2) 判断 name 变量对应的值是否以 "al" 开头,并输出结果 print(name.startswith(('al'))) # 3) 判断 name 变量对应的值是否以 "X" 结尾,并输出结果 print(name.endswith('X')) # 4) 将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果 print(name.replace('l','p')) # 5) 将 name 变量对应的值根据 “l” 分割,并输出结果。 print(name.split('l')) # 6) 将 name 变量对应的值变大写,并输出结果 print(name.upper()) # 7) 将 name 变量对应的值变小写,并输出结果 print(name.lower()) # 8) 请输出 name 变量对应的值的第 2 个字符? print(name[1]) # 9) 请输出 name 变量对应的值的前 3 个字符? print(name[:3]) # 10)请输出 name 变量对应的值的后 2 个字符? print(name[-2:]) # 11)请输出 name 变量对应的值中 “e” 所在索引位置? print(name.find('e')) # 12)获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。 print(name[:-1])
1.3 列表
作用：可以存多个值，例如爱好、课程、多个朋友等。
定义：[]内可以有多个任意类型的值，例如：数字、字符串、列表、字典、元组等。
常用操作：
索引
切片
追加
删除
长度
包含
1.3.1 索引
索引，即为下标，与字符串类似；可以通过下标进行访问列表的值，从左往右，按照顺序进行访问，例如：
my_friends=['jack','tom','frank',4,10,30] print(my_friends[1])
1.3.2 切片
从列表中切出子列表，例如：
my_friends=['jack','tom','frank',4,10,30] print(my_friends[1:5])
运行结果：
['tom', 'frank', 4, 10]
1.3.3 追加
利用列表的方法append，向列表尾部添加元素，例如：
my_friends=['jack','tom','frank',4,10,30] my_friends.append('mary') print(my_friends)
运行结果：
['jack', 'tom', 'frank', 4, 10, 30, 'mary']
1.3.4 删除
列表的删除有pop、remove，具体用法，用例子进行说明，例如：
my_friends=['jack','tom','frank',4,10,30,'mary'] # pop按照索引进行删除 my_friends.pop() # 从列表尾部删除 my_friends.pop(0) # 从列表头部删除 my_friends.pop(2) # 从指定位置删除 print(my_friends) # 运行结果：['tom', 'frank', 10, 30] my_friends=['jack','tom','frank',4,10,30,'mary'] #remove按照值进行删除 my_friends.remove('frank') # 删除值为frank print(my_friends) # 运行结果：['jack', 'tom', 4, 10, 30, 'mary']
1.3.5 长度
计算列表长度，利用列表的内置方法__len__()进行计算，python也提供了len()方法计算列表长度，例如：
my_friends=['jack','tom','frank',4,10,30,'mary'] print(my_friends.__len__()) # 内置方法__len__() 结果：7 print(len(my_friends)) # 利用方法len() 结果：7
1.3.6 成员运算，包含(in)
成员运算，主要利用in判断成员是否在列表存在，例如：
my_friends=['jack','tom','frank',4,10,30,'mary'] print('mary' in my_friends) # 运行结果：True
1.3.7 插入
插入元素，利用insert
my_friends=['jack','tom','frank',4,10,30,'mary'] my_friends.insert(0,'abc') # 从开始位置插入 my_friends.insert(2,'cat') # 指定位置插入 print(my_friends)
1.3.8 其他操作
my_friends=['jack','tom','frank',4,10,30,'mary'] # my_friends.clear() # 清空列表的值 new_list=my_friends.copy() # copy一个列表 my_friends.count('jack') # 统计元素在列表中的次数 my_friends.extend(['jack1','jack2','jack3']) # 一次添加多个元素 my_friends.index('tom') # 查看元素在列表中的下标 my_friends.reverse() # 列表翻转
1.3.9 模拟队列
#队列：先进先出 fifo=[] # 入队 fifo.append('first') fifo.append('second') fifo.append('third') # 出队 fifo.pop(0) fifo.pop(0) fifo.pop(0) # 入队 fifo.insert(0,'first') fifo.insert(0,'second') fifo.insert(0,'third') # 出队 fifo.pop() fifo.pop() fifo.pop()
1.3.10 模拟堆栈
#堆栈：先进后出 filo=[] # 入栈 filo.append('first') filo.append('second') filo.append('third') print(filo) # 出栈 filo.pop() filo.pop() filo.pop() # 入栈 filo.insert(0,'first') filo.insert(0,'second') filo.insert(0,'third') # 出栈 filo.pop(0) filo.pop(0) filo.pop(0)
1.4 元组
作用：存多个值，对比列表来说，元组不可变；主要用来读
特点：不可变，进行读操作，可与列表对比学习
常用操作：
索引
切片
循环
长度
包含in
1.4.1 定义
例如：
age=(11,22,33,44,55,33)# 本质age=tuple((11,22,33,44,55))
1.4.2 使用
age=(11,22,33,44,55,33) print(age[1]) # 按索引取值 print(age[1:4]) # 元组的切片 print(len(age)) # 获取元组的元素个数 print(age.__len__()) # 获取元组的元素个数 print(35 in age) # 判断元素是否是元组的元素 print(age.count(33)) # 判断元素在元组中的数量 print(age.index(44)) # 获取元素在元组中的索引
1.4.3 练习
简单购物车：
# 实现打印商品详细信息， # 用户输入商品名和购买个数， # 则将商品名，价格，购买个数加入购物列表， # 如果输入为空或其他非法输入则要求用户重新输入 msg_dic={ 'apple':10, 'tesla':100000, 'mac':3000, 'lenovo':30000, 'chicken':10, } goods_list=[] while True: for key in msg_dic: print(' 33[43mName:{name} Price:{price} 33[0m'.format(name=key,price=msg_dic[key])) choice=input('pls input your goods>>：') if len(choice) == 0 or choice not in msg_dic: continue count=input('pls input your number>>:') if not count.isdigit(): continue goods_list.append((choice,msg_dic[choice],count)) print(goods_list)
1.5 字典
作用：存多个值，用key-value进行存取，取值方便，速度快
特点：字典的key必须是不可变类型，也成为可hash类型
常用操作：
存/取
删除
键值
长度
循环
包含in
1.5.1 定义
字典的key必须是不可变类型（数字、字符串、元组），值可以是任意类型
定义的方式：
info={'name':jack,'age':18,'sex':'male'}
#本质info=dict({'name':jack,'age':18,'sex':'male'})
1.5.2 存/取
# 字典的取值，赋值 info={'name':'jack','age':18,'sex':'male'} print(info['age']) # 取值 info['height']=1.80 # 存值
1.5.3 删除
通过字典的pop方法，进行删除；pop方法有两个参数，通过指定key进行删除子点的元素
info={'name':'jack','age':18,'sex':'male'}
print(info.pop('name'))
# print(info)
print(info.pop('tom',None))
1.5.4 获取
利用get获取字典的值，如果key不存在，返回None，不报错；例如：
info={'name':'jack','age':18,'sex':'male'}
print(info['name']) # key不存在，报错
print(info.get('name')) # key不存在，返回None
print(info.get('addr','not key')) # key不存在，返回not key
1.5.5 其他方法
info={'name':'jack','age':18,'sex':'male'}
print(info.popitem()) # 随机删除一个元素
print(info.keys()) # 获取字典所有的key
print(info.values()) # 获取字典所有的value
# 循环字典
for key in info:
print(key)
for key in info:
print(key,info[key])
# 字典的items()方法
for key,val in info.items(): # key,val == ('name','jack')
print(key,val)
1.5.6 fromkeys
利用fromkeys方法，进行初始化字典
dic=dict.fromkeys(['name','age','sex'],None) print(dic) print(dict([('name', 'jack'), ('age', 18), ('sex', 'male')]))
2.5.7 update
update用新的字典更新原来字典，如果原来字典没有，直接把新字典添加原来字典
info={'name':'jack','age':18,'sex':'male'}
dic={'a':1,'b':2,'name':'mary','sex':'female'}
info.update(dic)
print(info)
1.5.8 练习
# 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]， # 将所有大于 66 的值保存至字典的第一个key中， # 将小于 66 的值保存至第二个key的值中。 # 即： {'k1': 大于66的所有值, 'k2': 小于66的所有值} list=[11, 22, 33, 44, 55, 66, 77, 88, 99, 90] dic={'k1':[],'k2':[]} for key in list: if key > 66: dic['k1'].append(key) elif key < 66: dic['k2'].append(key) print(dic) # 统计s='hello alex alex say hello sb sb'中每个单词的个数 # 结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2} s='hello alex alex say hello sb sb' word_list=s.split() dic={} print(word_list) for key in word_list: if key in dic: dic[key]=dic[key]+1 else: dic[key]=1 print(dic)
1.6 集合
作用：关系运算，去除重复的元素
常用方法：
in和not in
& 交集
| 并集
- 差集
^ 对称差集
>,>= ,<,<= 父集、子集
1.6.1 定义
定义：由不同元素组成的集合，集合中是一组无序排列的可hash的值，可以作为字典的key
目的：将不同的值存放在一起，不同的集合间用来做关系运算，无序纠结于集合中的单个值。
s={1,}
特点：
- 集合内可以有多个元素，但是每个元素都必须是不可变类型，即可hash类型
- 集合内的元素必须唯一
- 集合内的元素是无序的
s={1,'a',1,2,3,2,2,1} # s=set({1,'a',1,2,3,2,2,1})
s1=set('hello')
print(s1,type(s1))
1.6.2 成员运算
判断一个元素是否在集合中，可以用in、not in进行判断，例如：
pythons={'jack','mary','yuanhao','tom','gangdan','biubiu'}
print('jack' in pythons)
print('frank' not in pythons)
1.6.3 关系运算
#关系运算 s1={1,10,11,22} s2={1,11,33} #交集 print(s1 & s2) #并集 print(s1 | s2) #差集 print(s1 - s2) print(s2 - s1) #对称差集 print(s1 ^ s2) #父集 s1={1,2,3,4} s2={1,5} print(s1 >= s2) #子集 print(s1 <= s2) print(s2 <= s1)
1.6.4 练习
#集合练习一 pythons={'jack','mary','yuanhao','wupeiqi','gangdan','biubiu'} linuxs={'wupeiqi','tom','gangdan'} # 1. 求出即报名python又报名linux课程的学员名字集合 print(pythons & linuxs) # 2. 求出所有报名的学生名字集合 print(pythons | linuxs) # 3. 求出只报名python课程的学员名字 print(pythons - linuxs) # 4. 求出没有同时这两门课程的学员名字集合 print(pythons ^ linuxs) # 集合练习二 # 1. 有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表, # 且新列表无需保持列表原来的顺序 l=['a','b',1,'a','a'] s=set(l) print(s) last_list=list(s) print(last_list) # 2.在上题的基础上，保存列表原来的顺序 l=['a','b',1,'a','a'] new_list=[] for item in l: if item not in new_list: new_list.append(item) print(new_list) new_list=[] s=set() for item in l: if item not in s: s.add(item) new_list.append(item) print(new_list) # 3.有如下列表，列表元素为不可hash类型，去重，得到新列表， # 且新列表一定要保持列表原来的顺序 l=[ {'name':'jack','age':18,'sex':'male'}, {'name':'alex','age':73,'sex':'male'}, {'name':'jack','age':20,'sex':'female'}, {'name':'jack','age':18,'sex':'male'}, {'name':'jack','age':18,'sex':'male'}, ] l1=[] for item in l: if item not in l1: l1.append(item) print(l1) ll=[] s=set() for item in l: val=(item['name'],item['age'],item['sex']) if val not in s: s.add(val) ll.append(item) print(ll)
1.6.5 内置方法
#集合的内置方法 pythons={'jack','mary','frank','cat','gangdan','biubiu'} linuxs={'cat','tom','frank'} # 1. 求出即报名python又报名linux课程的学员名字集合 print(pythons & linuxs) print(pythons.intersection(linuxs)) # 2. 求出所有报名的学生名字集合 print(pythons | linuxs) print(pythons.union(linuxs)) # 3. 求出只报名python课程的学员名字 print(pythons - linuxs) print(pythons.difference(linuxs)) # 4. 求出没有同时这两门课程的学员名字集合 print(pythons ^ linuxs) print(pythons.symmetric_difference(linuxs))
1.6.6 add
利用集合的add方法，向集合中添加元素
s={1,2,'a','hello'}
s.add('jack')
print(s)
1.6.7 删除
s={1,2,'a','hello','jack'}
s.pop() # 随机删除
s.remove('jack') # 指定元素删除，元素不存在报错
s.discard('mary') # 指定元素删除，元素不存在不报错
1.7 总结
按存值个数区分
标量、原子类型：数字，字符串
容器类型： 列表，元组，字典
按可变不可变区分
可变： 列表，字典
不可变：数字，字符串，元组
按访问方式区分
直接访问： 数字
按照索引访问（序列类型）：字符串，列表，元组
按照key访问（映射类型）： 字典
2. 字符编码
以下两个场景下会涉及到字符编码的问题：
- 一个python文件中的内容是由一堆字符组成的
- python中的数据类型字符串是由一串字符组成的
需要强调的一点是：
unicode：简单粗暴，所有字符都是2Bytes，优点是：字符à数字的转换速度快，缺点是占用空间大
utf-8：精准，对不同的字符用不同的长度表示，优点是节省空间，缺点是：字符à数字的转换速度慢，因为每次都需要计算出字符需要多长的Bytes才能准确表示
注意：
- 内存中使用的编码是unicode，用的是空间换时间(程序都需要加载到内存才能运行，因而内存应该是尽可能的保证快)
- 硬盘中或者网络传输用utf-8，网络I/O延迟或磁盘I/O延迟要远大于uft-8的转换延迟，因而I/O应该是尽可能的节省带宽，保证数据传输的稳定性。
字符编码的转换流程：
总结：
无论用何种编辑器，要防止文件出现乱码（请一定要注意：存放一段代码的文件也仅仅是一个普通文件而已，此处指的是文件没有执行前，我们打开文件时出现的字符），核心法则：文件以什么编码保存，就以什么编码方式打开。
3.文件操作
文件的复杂操作,其实就两种操作:读和写,其他操作在Python的开发中都不用太关注,主要是因为操作系统已经帮我们做其他方面的工作。
文件操作步骤：
- 打开文件
- 对文件进行操作
- 关闭文件
3.1 文件读
读模式不能进行写操作，只能进行读操作
f = open('a.txt','r',encoding='utf-8') # 应用程序向操作系统发起的请求，指定utf-8编码、以只读的方式打开文件 res = f.read() # read方法，是文件头读到文件尾部 print(res) # 打印文件读取结果 f.readline() # 一次读取一行 f.readlines() # 读取所有行 f.close() # 关闭文件操作 关闭的是操作系统的文件句柄，变量f还存在，已经不能对文件进行操作 with open('a.txt','r',encoding='utf-8') as f: # 此种方法对文件操作完成后，会自动调用f.close(),关闭文件操作句柄 pass
3.2 文件写
写模式，只能对文件进行写操作，不能进行读
f = open('a.txt','w',encoding='utf-8') # 应用程序向操作系统发起的请求，指定utf-8编码、以只写的模式打开文件 f.write('111 ') # 单个值的写 f.write('222 ') f.writelines(['a ','b ','c ']) # 列表的写 f.close()
3.3 文件修改操作
文件修改操作，类似于vim的编辑，先把修改文件保存到临时文件夹中，让后删除原来文件，最后把临时文件重新命名为源文件。例如：
import os # 文件修改 with open('old.txt','r',encoding='utf-8') as read_f, open('.old.txt.swap','w',encoding='utf-8') as write_f: for line in read_f: if 'jack' in line: line = line.replace('jack','mary') write_f.write(line) os.remove('old.txt') os.rename('.old.txt.swap','old.txt')