一、数据与数据类型
1 什么是数据？
x=10，10是我们要存储的数据
2 为何数据要分不同的类型
数据是用来表示状态的，不同的状态就应该用不同的类型的数据去表示
3 数据类型
数字（int）
字符串 （str）
列表 （list）
元组 （tuple）
字典 (dict)
集合 (set)
二、基础数据类型
2.1数字 int
数字主要是用于计算用的，使用方法并不是很多，就记住一种就可以：
#bit_length() 当十进制用二进制表示时，最少使用的位数 a = 3 b = 5 print(a.bit_length()) print(b.bit_length()) 结果如何下： 2 3 Process finished with exit code 0 换算如下： 二进制 十进制 0000 0001 1 0000 0010 2 0000 0011 3
2.2 布尔值 bool
布尔值就两种：True、False。就是反应条件的正确与否。
真 <==> 1 <==> True 假 <==> 0 <==> False int --> str: str(int) str --> int: int(str) #str必须全部是数字组成。 int --> bool : 0 =False 非零=True bool --> int : int(True)=1 int(False)=0 str --> bool : ''(空) =False 非空字符串=True
2.3 字符串 str
2.3.1 字符串的所以与切片
索引即下标，就是字符串组成的元素从第一个开始，初始索引为0依次类推。
a = 'ABCDKDSEKD' print(a[0]) print(a[2]) print(a[-1]) print(a[-2]) 结果为： A C D K Process finished with exit code 0
切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾尾）
a = 'ABCDKDSEKD' print(a[0:3]) print(a[2:5]) print(a[0:]) #默认到最后 print(a[0:-1]) #-1就是最后一个 print(a[-1::-1]) #倒序，必须加反向步长 print(a[0:5:2]) #加步长 print(a[5:0:-2]) #反向加步长 结果为： ABC CDK ABCDKDSEKD ABCDKDSEK DKESDKDCBA ACK DDB Process finished with exit code 0
2.3.2 字符串的常用方法
s = 'qingSHANGlys' #定义一个字符串 s （1）# * capitalize 首字母大写，其他字母小写 print(s.capitalize()) 结果为： Qingshanglys （2）# *** 全部大写upper() 全部小写lower() print(s.upper()) print(s.lower()) 结果为： QINGSHANGLYS qingshanglys #注 upper 和lower可以实现验证码功能，如下： code = 'QeAr'.upper() your_code = input('请输入验证码：').upper() if your_code == code: print('验证成功') else: print('验证失败') (3)#* 大小写反转 swapcase() print(s.swapcase()) 结果为： QINGshangLYS （4）#*非字母的元素隔开的每个单词首字母大写 title() s = 'alex wusir*oldboy3taibia' print(s.title()) 结果为： Alex Wusir*Oldboy3Taibia （5）# center 居中，长度自己设定，可自定义填充物，默认填充物None print(s.center(30)) print(s.center(30,'*')) 结果为： alex wusir*oldboy3taibia ***alex wusir*oldboy3taibia*** （6）# *** startswith 判断是否以...开头 可切片
# *** endswith判断是否以...结尾 可切片
s = 'qingSHANGlys'
print(s.startswith('qi',0,2))
print(s.startswith('Q'))
print(s.endswith('s'))
print(s.endswith('S'))
结果为：
True
False
True
False
(7)# *** strip 去除首尾的空格，制表符\t,换行符。不仅仅是去除空格....(lstrip()只去除左边、 rstrip()只去除右边)
s = ' tyoyldBoyrtet '
print(s)
s1 = s.strip()
print(s1)
print(s1.strip('t')) #去除首尾的‘t’
结果为：
tyoyldBoyrtet
tyoyldBoyrtet
yoyldBoyrte
(8)*** split (str ---> list) 以什么分割，最终形成一个列表此列表不含有这个分割的元素。
s='liuyisai,lys,qingshan'
print(s.split(','))
print(s.split('s'))
print(s.split('s',2)) #指定分隔符服个数
结果为：
['liuyisai', 'lys', 'qingshan']
['liuyi', 'ai,ly', ',qing', 'han']
['liuyi', 'ai,ly', ',qingshan']
(9)#join 将list --->str
s1 = 'lys'
print('+'.join(s1))
s2 = ['lys','qingshan','liuyisai']
print('+'.join(s2))
结果为：
l+y+s
lys+qingshan+liuyisai
(10)#replace 替换
s1='lys say you beautiful'
s2 = s1.replace('lys','qingshan')
print(s2)
结果为：
qingshan say you beautiful
(11)#find 通过元素找索引 找不到返回-1
# index 通过元素找索引 找不到报错
s = 'qingshanlys'
print(s.find('s')) #4
print(s.find('lys')) #8
print(s.find('b')) #-1
print(s.index('y')) #9
print(s.index('b')) #报错
(12)#格式化输出format
res = '我叫{},今年{}岁，爱好{}'
print(res) #我叫{},今年{}岁，爱好{}
res='我叫{0}今年{1}岁，爱好{2},我依然叫{0}'.format('lys',25,'girl')
print(res) #我叫lys今年25岁，爱好girl,我依然叫lys
res='我叫{name}今年{age}岁，爱好{hobby}'.format(hobby='gril', name='lys', age=25)
print(res) #我叫lys今年25岁，爱好gril
(13)#公共方法：len 长度
count 数量
s = 'fdsafasdfasdfsadf'
print(len(s)) #17
print(s.count('a')) #4
#####is系列
s = 'lys123'
print(s.isdigit()) #False #字符串只由数字组成
print(s.isalpha()) #False #字符串只由字母组成
print(s.isalnum()) #Ture #字符串由字母或数字组成
s = input('请输入数字：').strip() #删除前后空格
if s.isdigit(): #判断是否为数字
print('OK')
else:
print('erre')
2.4列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：
li = [‘lys’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’lys’}]
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。
li = ['lys',25,'boy','shandong'] print(li[0]) #lys print(li[-1]) #shandong -1代表最后一个元素的索引 print(li[:2]) #['lys', 25] 切片 print(li[:3:2]) #['lys', 'boy'] 加步长
2.4.1 list 赠
li = ['lys',25,'boy','shandong'] #append 在最后追加 li.append('girl') li.append([1,2,3]) print(li) 结果为： ['lys', 25, 'boy', 'shandong', 'girl', [1, 2, 3]] #insert 按照索引插入到指定位置 li.insert(0,'girl') li.insert(2,[1,2,3]) print(li) 结果为： ['girl', 'lys', [1, 2, 3], 25, 'boy', 'shandong'] #extend 迭代着添加 li.extend('girl') li.extend(['111',222,333]) print(li) 结果为['lys', 25, 'boy', 'shandong', 'g', 'i', 'r', 'l', '111', 222, 333]
2.4.2 list 删
li = ['lys',25,'boy','shandong'] (1)#pop 有返回值 按照索引删除 print(li.pop(2)) print(li) 结果为： boy ['lys', 25, 'shandong'] (2)#remove 按照元素去删，没有返回值 print(li.remove('lys')) print(li) 结果为： None [25, 'boy', 'shandong'] (3)#clear 清空列表 li.clear() print(li) 结果为： [] (4)#del 内存级别删除列表，支持切片 del li print(li) #按索引删除 del li[-1] print(li) 结果为： ['lys', 25, 'boy'] #切片删除 del li[:2] print(li) 结果为： ['boy', 'shandong']
2.4.3 list 改
li = ['lys',25,'boy','shandong'] #按照索引改 print(li[2]) #boy li[2] = 'girl' print(li) #['lys', 25, 'girl', 'shandong'] #按照切片去改 li[:2] = 'abc' print(li) 结果为： ['a', 'b', 'c', 'boy', 'shandong'] li[1:3] = [111,222,333,444] print(li) 结果为： ['lys', 111, 222, 333, 444, 'shandong']
2.4.4 list 查
li = ['lys',25,'boy','shandong'] #按照索引去查询 print(li[0]) #lys #按照切片去查询 print(li[1:3]) #[25, 'boy'] #循环查询 for i in li: print(i)
2.4.5 list 其他操作
li = [1,2,3,1,2,2,2,3,1] (1)#count 统计某个元素在列表中出现的次数 print(li.count(2)) #4 (2)#len 统计元素总个数 print(len(li)) #9 (3)sort 用于在原位置对列表进行排序 l2 = [3,2,4,6,9,8,7,1] l2.sort() #默认从小到大排序 print(l2) #[1, 2, 3, 4, 6, 7, 8, 9] l2.sort(reverse=True) #从大到小排序 print(l2) #[9, 8, 7, 6, 4, 3, 2, 1] (4)#reverse 将列表中的元素反向存放 l2.reverse() print(l2) #[1, 7, 8, 9, 6, 4, 2, 3] (5)#index 用于从列表中找出某个值第一个匹配项的索引位置 print(li.index(2)) #1
2.5 字典dict
字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。
字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
key:不可变的数据类型(可哈希)：str，bool，tuple，int。
value：任意数据类型。
数据类型分类：
不可变的数据类型(可哈希)：str，bool，tuple，int
可变的数据类型：dict，list，set。 容器类数据类型：list，tuple，dict，set.
字典：存储数据多，关系型数据，查询速度快（二分查找）。
3.6版本之前，字典是无序的，3.6之后字典是有序的。
2.5.1 字典dict 赠
dic = {'name':'lys','age':25,'hobby':'girl'}
(1)dic['high'] = 178 #有则覆盖，无则添加
print(dic) #{'name': 'lys', 'age': 25, 'hobby': 'girl', 'high': 178}
dic['name'] = '青衫'
print(dic) #{'name': '青衫', 'age': 25, 'hobby': 'girl'}
(2)#setdefault() 有则不变，无则添加
dic.setdefault('high',178)
print(dic) #{'name': 'lys', 'age': 25, 'hobby': 'girl', 'high': 178}
dic.setdefault('name','青衫')
print(dic) #{'name': 'lys', 'age': 25, 'hobby': 'girl'}
2.5.2 字典dict 删
dic = {'name':'lys','age':25,'hobby':'girl'}
(1)#pop('key') 删除指定的健，有返回值、返回对应的值
print(dic.pop('hobby')) #girl
print(dic) #{'name': 'lys', 'age': 25}
(2)#clear() 清空
dic.clear()
print(dic) #{}
(3)#popitem() 随机删除，返回值{3.6及以后版本删除最后一个值，不再随机}
print(dic.popitem()) #('hobby', 'girl')
print(dic) #{'name': 'lys', 'age': 25}
(4)#del 内存级别删除
del dic['age']
print(dic) #{'name': 'lys', 'hobby': 'girl'}
del dic
print(dic) #已找不到该字典
2.5.3 字典dict 改
dic = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic.update(dic2) #update() 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
结果为：{'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
2.5.4 字典dict 查
dic = {'name':'lys','age':25,'hobby':'girl'}
print(dic['name']) #lys
print(dic['name1']) #报错 so: 没有会报错
print(dic.get('hobby')) #girl
print(dic.get('hobby1')) #None
print(dic.get('hobby1','没有此值')) #没有此值 so:查不到返回指定的值，默认为None
2.5.5 字典dict的其他操作
dic = {'name':'lys','age':25,'hobby':'girl'}
(1)#items()
item = dic.items()
print(item,type(item))
结果为：
dict_items([('name', 'lys'), ('age', 25), ('hobby', 'girl')]) <class 'dict_items'> #这个类型就是dict_items类型，可迭代的
for i in dic:
print(i)
结果为：#循环取出dic 所以的key
name
age
hobby
for i in dic.items():
print(i)
结果为：
('name', 'lys')
('age', 25)
('hobby', 'girl')
for k,v in dic.items():
print(k,v)
结果为：
name lys
age 25
hobby girl
(2)keys() for i in dic.keys(): print(i) 结果为： #循环取出字典dic的所以key name age hobby (3)values() for i in dic.values(): print(i) j结果为：循环取出字典dic的所以value lys 25 girl
2.6 元组 tulpe
元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。例：（1，2，3）（"a","b","c"）
tu = (11,2,True,[2,3,4],'lys') for i in tu: print(i) 结果为： 11 2 True [2, 3, 4] lys print(tu[2]) #True print(tu.index('lys')) #4 tu[-2].append(666) #子不可变，孙看变 print(tu) #(11, 2, True, [2, 3, 4, 666], 'lys')
2.7 集合 set
集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：
去重，把一个列表变成集合，就自动去重了。
关系测试，测试两组数据之前的交集、差集、并集等关系。
2.7.1 集合的创建
set1 = {1,2,3,4}
set2 = {'a','b','c'}
print(set1,set2)
结果为：
{1, 2, 3, 4} {'a', 'c', 'b'}
2.7.2 集合的赠
set1 = {'lys','qingshan','liuyisai','liu'}
set1.add(666) #位置随机
print(set1) #{'liuyisai', 'lys', 'liu', 666, 'qingshan'}
set1.update('abc') #迭代着增加
print(set1) #{'liuyisai', 'lys', 'liu', 'c', 'a', 'b', 666, 'qingshan'}
set1.update(['a1','b2','c3'])
print(set1) #{'lys', 'liuyisai', 'c3', 'b2', 'liu', 'a1', 'qingshan'}
2.7.3 集合的删
set1 = {'lys','qingshan','liuyisai','liu'}
set1.remove('liuyisai') #删除一个指定元素
print(set1) #{'liu', 'lys', 'qingshan'}
set1.pop() #随机删除一个元素
print(set1)
set1.clear() #清空集合
print(set1) #set()
del set1 #删除集合
print(set1)
2.7.4 集合的去重功能
list = ['a','b','a',1,1,1,2] print(set(list)) #{1, 2, 'b', 'a'}
2.7.5 集合的交集（& 或者 intersection）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2) #{4, 5}
2.7.6 集合的并集 （| 或者 union）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2) #{1, 2, 3, 4, 5, 6, 7, 8}
2.7.7 集合的差集 （- 或者 difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2) #{1, 2, 3}
2.7.8 集合的反交集
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2)
结果为：
{1, 2, 3, 6, 7, 8}
2.7.9 集合子集与超集
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1 < set2)
print(set1.issubset(set2)) # 这两个相同，都是说明set1是set2子集。
print(set2 > set1)
print(set2.issuperset(set1)) # 这两个相同，都是说明set2是set1超集。
2.7.10 frozenset 不可变集合，让集合变成不可变类型。
s = frozenset('barry') print(s,type(s)) # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>
三、其他（enumerate，range，以及分别赋值等）
enumerate :枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。
li =['lys','qingshan','linux','python','DB'] for i in enumerate(li): print(i) 结果为： (1, 'qingshan') (2, 'linux') (3, 'python') (4, 'DB') for index,name in enumerate(li): print(index,name) 结果为： 0 lys 1 qingshan 2 linux 3 python 4 DB for index,name in enumerate(li,5): #默认从0开始，可以指定起始位置 print(index,name) 结果为： 5 lys 6 qingshan 7 linux 8 python 9 DB
range：指定范围，生成指定数字，配合for循环使用，不能直接print
for i in range(10): #默认从0开始，顾头不顾尾 print(i) 结果为： 0 1 2 3 4 5 6 7 8 9 for i in range(5,10): #指定起始位置 顾头不顾尾 print(i) 结果为： 5 6 7 8 9 for i in range(5,10,2): #支持步长 print(i) 结果为： 5 7 9 for i in range(5,1,-1): #反向打印 print(i) 结果为： 5 4 3 2
fromkeys
dic1 = dict.fromkeys('abc','张三') print(dic1) dic2= dict.fromkeys([1,2,3],'李四') print(dic2) 结果为： {'a': '张三', 'b': '张三', 'c': '张三'} {1: '李四', 2: '李四', 3: '李四'}
dic3 = dict.fromkeys('abc',[])
# print(dic3)
dic3['a'].append('老男孩')
print(dic3)
结果为：
{'a': ['老男孩'], 'b': ['老男孩'], 'c': ['老男孩']}
四、数据类型补充
l1 = ['alex', 'wusir', 'taibai', 'barry', '老男孩'] del l1[1::2] print(l1) for i in range(len(l1)): print(l1) # ['alex', 'wusir', 'taibai', 'barry', '老男孩'] # ['alex', 'wusir', 'taibai', 'barry', '老男孩'] # ['alex', 'taibai', 'barry', '老男孩'] # ['alex', 'taibai', 'barry', '老男孩'] print(i) # 0 1 2 3 if i % 2 == 1: del l1[i] print(l1) # ['alex', 'wusir', 'taibai', 'barry', '老男孩'] # ['alex', 'taibai', 'barry', '老男孩'] # ['alex', 'taibai', 'barry'] print(i) # 0 1 #再循环一个列表时，不要对列表进行删除的动作(改变列表元素的个数动作)，会出错 #dict 再循环字典时，不要改变字典的大小。 dic = {'k1':'v1','k2':'v2','k3':'v3','r':666} l1 = [] for i in dic: if 'k' in i: l1.append(i) # print(l1) for i in l1: del dic[i] print(dic) #tu 如果元组里面只有一个元素并且没有逗号隔开，那么他的数据类型与该元素一致。 tu1 = (1) print(tu1,type(tu1)) tu2 = ('alex') print(tu2,type(tu2)) tu3 = (['alex',1,2]) print(tu3,type(tu3))
五、深浅copy
1 先看赋值运算。
l1 = [1,2,3,['barry','alex']] l2 = l1 l1[0] = 5 l1[3][1] = 'lys' print(l1) #[5, 2, 3, ['barry', 'lys']] 34404952 print(l2) #[5, 2, 3, ['barry', 'lys']] 34404952 对于赋值运算来说，l1与l2指向的是同一个内存地址，所以他们是完全一样的。
2、浅拷贝copy。
l1 = [1,2,3,['barry','alex']] l2 = l1.copy() l1[3][1] = 'lys' l1[0] = 5 print(l1,id(l1)) #[5, 2, 3, ['barry', 'lys']] 6617688 print(l2,id(l2)) #[1, 2, 3, ['barry', 'lys']] 6617768 print(id(l1[3])) #34862664 print(id(l2[3])) #34862664 对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。
3、深拷贝deepcopy。
import copy l1 = [1,2,3,['barry','alex']] l2 = copy.deepcopy(l1) l1[3][1] = 'lys' l1[0] = 5 print(l1) #[5, 2, 3, ['barry', 'lys']] print(l2) #[1, 2, 3, ['barry', 'alex']] 对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变。