一、前言
1，什么是数据？
x = 20 # 20 是我们要存储的数据
2，为何数据要分不同的类型？
数据是用来表示状态的，不同的状态就应该用不同的类型的数据去表示。
3，数据类型：
1）数字（整型，长整型，浮点型，复数）
2）字符串
3）字节串：字符编码中有字节 bytes 类型
4）布尔型
5）列表
6）元组
7）字典
8）集合
4，按照以下几个点展开数据类型的学习
-------------------- 基本使用 -------------------- 1，用途 2，定义方式 3，常用操作 + 内置方法 -------------------- 类型总结 -------------------- 1，存一个值 or 存多个值 2，有序 or 无序 3，可变 or 不变 1）可变：值变，id 不变。 可变 = 不可hash 2）不可变：值变，id 就变。 不可变 = 可hash
二、数字
1，整型与浮点型
# 整型int 作用：年纪，等级，身份证号，qq号等整型数字相关 定义： age=10 # 本质age=int(10) # 浮点型float 作用：薪资，身高，体重，体质参数等浮点数相关 salary=3000.3 # 本质salary=float(3000.3) # 二进制，十进制，八进制，十六进制
2，其他数字类型（了解）
# 长整形（了解） 在python2中（python3中没有长整形的概念）： >>> num=2L >>> type(num) <type 'long'> # 复数（了解，推荐视频：https://www.bilibili.com/video/av26786159） >>> x=1-2j >>> x.real 1.0 >>> x.imag -2.0
三、字符串
1，定义：
# 作用：名字，性别，国籍，地址等描述信息 # 定义：在单引号双引号三引号内，由一串字符组成 name='zixi' # 优先掌握的操作： # 1，按索引取值(正向取+反向取) ：只能取 # 2，切片(顾头不顾尾，步长) # 3，长度len # 4，成员运算in和not in # 5，移除空白strip # 6，切分split # 7，循环
2，需要掌握的操作
# 1、strip,lstrip,rstrip # 2、lower,upper # 3、startswith,endswith # 4、format的三种玩法 # 5、split,rsplit # 6、join # 7、replace # 8、isdigit
# strip name = '*zixi**' print(name.strip('*')) # 去掉两边的* print(name.lstrip('*')) # 去掉左边的* print(name.rstrip('*')) # 去掉右边的* # lower,upper name = 'zixi' print(name.lower()) # 把字符串变成小写的 print(name.upper()) # 把字符串变成大写的 # startswith,endswith # 以什么开头结尾，返回布尔值 name = 'alex_SB' print(name.endswith('SB')) print(name.startswith('alex')) # format的三种玩法 res = '{} {} {}'.format('zixi',18,'male') # zixi 18 male res1 = '{1} {0} {1}'.format('zixi',18,'male') # 18 zixi 18 res2 = '{name} {age} {sex}'.format(sex='male',name='zixi',age=18) # zixi 18 male # split name = 'root:x:0:0::/root:/bin/bash' print(name.split(':')) # 默认分隔符为空格,['root', 'x', '0', '0', '', '/root', '/bin/bash'] name = 'C:/a/b/c/d.txt' # 只想拿到顶级目录 print(name.split('/',1)) # ['C:', 'a/b/c/d.txt'] name = 'a|b|c' print(name.rsplit('|',1)) # 从右开始切分，['a|b', 'c'] # join tag = ' ' print(tag.join(['zixi','say','hello','world'])) # 可迭代对象必须都是字符串,zixi say hello world #replace name = 'old_six say :i have one tesla,my name is old_six' print(name.replace('old_six','SB',1)) # SB say :i have one tesla,my name is old_six # isdigit：可以判断 bytes和 unicode类型,是最常用的用于于判断字符是否为"数字"的方法 age = input('>>: ') print(age.isdigit())
3，其他操作（了解）
# 1、find,rfind,index,rindex,count # 2、center,ljust,rjust,zfill # 3、expandtabs # 4、captalize,swapcase,title # 5、is数字系列 # 6、is其他
# find,rfind,index,rindex,count name = 'zixi say hello' print(name.find('o',1,3)) # 顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引 # print(name.index('e',2,4)) # 同上,但是找不到会报错 print(name.count('e',1,3)) # 顾头不顾尾,如果不指定范围则查找所有 # center,ljust,rjust,zfill name = 'zixi' print(name.center(30,'-')) # -------------zixi------------- print(name.ljust(30,'*')) # zixi************************** print(name.rjust(30,'*')) # **************************zixi print(name.zfill(50)) # 用0填充,0000000000000000000000000000000000000000000000zixi # expandtabs：把字符串中的 tab 符号(' ')转为空格，tab 符号(' ')默认的空格数是 8。 name = 'zixi hello' print(name) # zixi hello print(name.expandtabs(1)) # zixi hello # capitalize,swapcase,title print(name.capitalize()) # 首字母大写，Zixi hello print(name.swapcase()) # 大小写翻转，ZIXI HELLO msg = 'zixi say hi' print(msg.title()) # 每个单词的首字母大写，Zixi Say Hi # is数字系列 # 在python3中 num1 = b'4' # bytes num2 = u'4' # unicode,python3中无需加u就是unicode num3 = '四' # 中文数字 num4 = 'Ⅳ' # 罗马数字 # isdigit:bytes,unicode 判断是否是数字 print(num1.isdigit()) # True print(num2.isdigit()) # True print(num3.isdigit()) # False print(num4.isdigit()) # False # isdecimal:unicode，检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。 # bytes类型无isdecimal方法 print(num2.isdecimal()) # True print(num3.isdecimal()) # False print(num4.isdecimal()) # False # isnumeric:unicode,检测字符串是否只由数字组成。这种方法是只针对unicode对象。 # bytes类型无isnumeric方法 print(num2.isnumeric()) # True print(num3.isnumeric()) # True print(num4.isnumeric()) # True # 三者不能判断浮点数 num5 = '4.3' print(num5.isdigit()) print(num5.isdecimal()) print(num5.isnumeric()) ''' 总结: 最常用的是 isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景 如果要判断中文数字或罗马数字,则需要用到isnumeric ''' # is其他 print('===>') name = 'zixi123' print(name.isalnum()) # 字符串由字母或数字组成,True print(name.isalpha()) # 字符串只由字母组成,False print(name.isidentifier()) # True,判断字符串是否是有效的 Python 标识符，即可用此方法来判断变量名是否合法。 print(name.islower()) # True,是小写么 print(name.isupper()) # False，是大写么 print(name.isspace()) # False，检测字符串是否只由空格组成。 print(name.istitle()) # False，检查每个单词是否以大写字母开头
4，练习
# 写代码,有如下变量,请按照要求实现每个功能 （共6分，每小题各0.5分） name = " zolinG" # 1) 移除 name 变量对应的值两边的空格,并输出处理结果 # 2) 判断 name 变量对应的值是否以 "zo" 开头,并输出结果 # 3) 判断 name 变量对应的值是否以 "G" 结尾,并输出结果 # 4) 将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果 # 5) 将 name 变量对应的值根据 “l” 分割,并输出结果。 # 6) 将 name 变量对应的值变大写,并输出结果 # 7) 将 name 变量对应的值变小写,并输出结果 # 8) 请输出 name 变量对应的值的第 2 个字符? # 9) 请输出 name 变量对应的值的前 3 个字符? # 10) 请输出 name 变量对应的值的后 2 个字符? # 11) 请输出 name 变量对应的值中 “i” 所在索引位置? # 12) 获取子序列,去掉最后一个字符。如: oldsix 则获取 oldsi。
# 写代码,有如下变量,请按照要求实现每个功能 # name = " zolinG" # 1)移除 name 变量对应的值两边的空格,并输出处理结果 name = " zolinG" a = name.strip() print(a) # 2)判断 name 变量对应的值是否以 "zo" 开头,并输出结果 name = " zolinG" if name.startswith(name): print(name) else: print('no') # 3)判断 name 变量对应的值是否以 "G" 结尾,并输出结果 name = " zolinG" if name.endswith(name): print(name) else: print('no') # 4)将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果 name = " zolinG" print(name.replace('l','p')) # zopinG # 5)将 name 变量对应的值根据 “l” 分割,并输出结果。 name = " zolinG" print(name.split('l')) # [' zo', 'inG'] # 6)将 name 变量对应的值变大写,并输出结果 name = " zolinG" print(name.upper()) # ZOLING # 7)将 name 变量对应的值变小写,并输出结果 name = " zolinG" print(name.lower()) # zoling # 8)请输出 name 变量对应的值的第 2 个字符? name = " zolinG" print(name[1]) # z # 9)请输出 name 变量对应的值的前 3 个字符? name = " zolinG" print(name[:3]) # zo # 10)请输出 name 变量对应的值的后 2 个字符? name = " zolinG" print(name[-2:]) # nG # 11)请输出 name 变量对应的值中 “i” 所在索引位置? name = " zolinG" print(name.index('i')) # 4 # 12)获取子序列,去掉最后一个字符。如: oldsix 则获取 oldsi。 name = " zolinG" a = name[:-1] print(a) # zolin
四、列表
1，定义，用法：
# 作用：多个装备，多个爱好，多门课程，多个女朋友等 # 定义：[]内可以有多个任意类型的值，逗号分隔 lis = ['zixi','zoling','zxc',4,5] # 本质lis = list([...]) # 也可以这么写 liss = list('abc') # 优先掌握的操作： # 1、按索引存取值(正向存取+反向存取)：即可存也可以取 # 2、切片(顾头不顾尾，步长) # 3、长度 # 4、成员运算in和not in # 5、追加 # 6、删除 # 7、循环
# ps:反向步长 l = [1,2,3,4,5,6] # 正向步长 print(l[0:3:1]) # [1, 2, 3] # 反向步长 print(l[2::-1]) # [3, 2, 1] # 列表翻转 print(l[::-1]) # [6, 5, 4, 3, 2, 1]
2，练习：
""" 1. 有列表 data = ['zixi',49,[1900,3,18]]， 分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量 2. 用列表模拟队列 3. 用列表模拟堆栈 4. 有如下列表，请按照年龄排序（涉及到匿名函数） """ l = [ {'name':'zixi','age':20}, {'name':'zoling','age':25}, {'name':'xiaohua','age':18}, ]
l = [ {'name':'zixi','age':20}, {'name':'zoling','age':25}, {'name':'xiaohua','age':18}, ] # 答案： l.sort(key=lambda item:item['age']) print(l) # [{'name': 'xiaohua', 'age': 18}, {'name': 'zixi', 'age': 20}, {'name': 'zoling', 'age': 25}]
# sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。 # 语法： list.sort(cmp=None, key=None, reverse=False) # 参数： """ cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。 key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。 reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。 """
五、元组
1，定义，用法：
# 作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读 # 定义：与列表类型比，只不过[]换成() age = (11,22,33,44,55) # 本质 age = tuple((11,22,33,44,55)) # 优先掌握的操作： # 1、按索引取值(正向取+反向取)：只能取 # 2、切片(顾头不顾尾，步长) # 3、长度 # 4、成员运算in和not in # 5、循环
2，练习：
# 简单购物车,要求如下： # 实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格， # 购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入 msg_dic = { 'apple':10, 'tesla':100000, 'mac':3000, 'lenovo':30000, 'chicken':10, }
msg_dic = { 'apple':10, 'tesla':100000, 'mac':3000, 'lenovo':30000, 'chicken':10, } goods_l = [] while True: for key,item in msg_dic.items(): # 遍历字典，得到键值对的键和值 print('name:{name} price:{price}'.format(price=item,name=key)) choice = input('商品>>: ').strip() if not choice or choice not in msg_dic:continue count = input('购买个数>>: ').strip() if not count.isdigit():continue goods_l.append((choice,msg_dic[choice],count)) # 把买的商品追加到购物车中 print(goods_l)
六、字典
1，定义，用法：
# 作用：存多个值,key-value存取，取值速度快 # 定义：key必须是不可变类型，value可以是任意类型 info = {'name':'zixi','age':18,'sex':'male'} # 本质info = dict({....}) # 或 info = dict(name='zixi',age=18,sex='male') # 或 info = dict([['name','zixi'],('age',18)]) # 或 {}.fromkeys(('name','age','sex'),None) # 优先掌握的操作： # 1、按key存取值：可存可取 # 2、长度len # 3、成员运算in和not in # 4、删除 # 5、键keys()，值values()，键值对items() # 6、循环
2，练习1：
# 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]， # 将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中 # 即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}
z = {'k1':[],'k2':[]}
c = [11,22,33,44,55,66,77,88,99,90]
for i in c:
if i > 66:
z['k1'].append(i)
else:
z['k2'].append(i)
print(z)
# {'k1': [77, 88, 99, 90], 'k2': [11, 22, 33, 44, 55, 66]}
3，练习2：
# 统计 s = 'hello zixi zixi say hello db db' 中每个单词的个数 # 结果如：{'hello': 2, 'zixi': 2, 'say': 1, 'db': 2}
s = 'hello zixi zixi say hello db db' l = s.split() dic = {} for item in l: if item in dic: dic[item] += 1 else: dic[item] = 1 print(dic) # {'hello': 2, 'zixi': 2, 'say': 1, 'db': 2}
3.1，其他做法（主要看setfault的用法）：
# for 循环，循环添加 s = 'hello zixi zixi say hello db db' dic = {} words = s.split() print(words) for word in words: dic[word] = s.count(word) print(dic) """ ['hello', 'zixi', 'zixi', 'say', 'hello', 'db', 'db'] {'hello': 2} {'hello': 2, 'zixi': 2} {'hello': 2, 'zixi': 2} {'hello': 2, 'zixi': 2, 'say': 1} {'hello': 2, 'zixi': 2, 'say': 1} {'hello': 2, 'zixi': 2, 'say': 1, 'db': 2} {'hello': 2, 'zixi': 2, 'say': 1, 'db': 2} """
# 利用setdefault解决重复赋值 """ setdefault的功能 1：key存在，则不赋值，key不存在则设置默认值 2：key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值 d = {} print(d.setdefault('a',1)) # 返回1 d = {'a':2222} print(d.setdefault('a',1)) # 返回2222 """ s = 'hello zixi zixi say hello db db' dic = {} words = s.split() for word in words: dic.setdefault(word,s.count(word)) print(dic) """ {'hello': 2} {'hello': 2, 'zixi': 2} {'hello': 2, 'zixi': 2} {'hello': 2, 'zixi': 2, 'say': 1} {'hello': 2, 'zixi': 2, 'say': 1} {'hello': 2, 'zixi': 2, 'say': 1, 'db': 2} {'hello': 2, 'zixi': 2, 'say': 1, 'db': 2} """
# 利用集合，去掉重复，减少循环次数 s = 'hello zixi zixi say hello db db' dic = {} words = s.split() words_set = set(words) for word in words_set: dic[word] = s.count(word) print(dic) """ {'hello': 2} {'hello': 2, 'db': 2} {'hello': 2, 'db': 2, 'zixi': 2} {'hello': 2, 'db': 2, 'zixi': 2, 'say': 1} """
七、集合
1，定义，用法：
""" 作用：去重，关系运算， 定义： 知识点回顾 可变类型是不可hash类型 不可变类型是可hash类型 定义集合: 集合：可以包含多个元素，用逗号分割， 集合的元素遵循三个原则： 1：每个元素必须是不可变类型(可hash，可作为字典的key) 2: 没有重复的元素 3：无序 注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值 优先掌握的操作： 1、长度len 2、成员运算in和not in 3、|合集 4、&交集 5、-差集 6、^对称差集 7、== 8、父集：>,>= 9、子集：<,<= """
2，练习1：
""" 关系运算： 有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合 pythons = {'托儿所','zixi','zoling','儿童劫','娃娃鱼','瑞萌萌'} linuxs = {'zixi','儿童劫','瑞萌萌'} 1. 求出即报名python又报名linux课程的学员名字集合 2. 求出所有报名的学生名字集合 3. 求出只报名python课程的学员名字 4. 求出没有同时这两门课程的学员名字集合 """
# 有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合 pythons = {'托儿所','zixi','zoling','儿童劫','娃娃鱼','瑞萌萌'} linuxs = {'zixi','儿童劫','瑞萌萌'} # 求出即报名python又报名linux课程的学员名字集合 print(pythons & linuxs) # 求出所有报名的学生名字集合 print(pythons | linuxs) # 求出只报名python课程的学员名字 print(pythons - linuxs) # 求出没有同时这两门课程的学员名字集合 print(pythons ^ linuxs) """ {'儿童劫', '瑞萌萌', 'zixi'} {'娃娃鱼', '瑞萌萌', '托儿所', 'zoling', '儿童劫', 'zixi'} {'托儿所', 'zoling', '娃娃鱼'} {'托儿所', 'zoling', '娃娃鱼'} """
3，练习2：
""" 去重: 1. 有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序 2.在上题的基础上，保存列表原来的顺序 3.去除文件中重复的行，肯定要保持文件内容的顺序不变 4.有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序 """ l = [ {'name':'zixi','age':18,'sex':'male'}, {'name':'zixi','age':18,'sex':'male'}, {'name':'zoling','age':20,'sex':'female'}, {'name':'zixi','age':18,'sex':'male'}, {'name':'zixi','age':18,'sex':'male'}, ]
# 去重,无需保持原来的顺序 l = ['a','b',1,'a','a'] print(set(l)) # {'a', 1, 'b'}
# 去重,并保持原来的顺序 # 方法一:不用集合 l = [1,'a','b',1,'a'] l1 = [] for i in l: if i not in l1: l1.append(i) print(l1) # [1, 'a', 'b']
# 方法二:借助集合 l = [1,'a','b',1,'a'] l1 = [] s = set() for i in l: if i not in s: s.add(i) l1.append(i) print(l1) # [1, 'a', 'b']
# 列表中元素为可变类型时,去重,并且保持原来顺序 l = [ {'name':'zixi','age':18,'sex':'male'}, {'name':'zixi','age':18,'sex':'male'}, {'name':'zoling','age':20,'sex':'female'}, {'name':'zixi','age':18,'sex':'male'}, {'name':'zixi','age':18,'sex':'male'}, ] # print(set(l)) # 报错:unhashable type: 'dict' s = set() l1 = [] for item in l: val = (item['name'],item['age'],item['sex']) if val not in s: s.add(val) l1.append(item) print(l1) # [{'name': 'zixi', 'age': 18, 'sex': 'male'}, {'name': 'zoling', 'age': 20, 'sex': 'female'}]
# 定义函数,既可以针对可以hash类型又可以针对不可hash类型 l = [ {'name':'zixi','age':18,'sex':'male'}, {'name':'zixi','age':18,'sex':'male'}, {'name':'zoling','age':20,'sex':'female'}, {'name':'zixi','age':18,'sex':'male'}, {'name':'zixi','age':18,'sex':'male'}, ] def func(items,key=None): s = set() for item in items: val = item if key is None else key(item) if val not in s: s.add(val) yield item print(list(func(l,key=lambda dic:(dic['name'],dic['age'],dic['sex'])))) # [{'name': 'zixi', 'age': 18, 'sex': 'male'}, {'name': 'zoling', 'age': 20, 'sex': 'female'}]
八、数据类型总结
1，按存储空间的占用分（从低到高）
# 数字 # 字符串 # 集合：无序，即无序存索引相关信息 # 元组：有序，需要存索引相关信息，不可变 # 列表：有序，需要存索引相关信息，可变，需要处理数据的增删改 # 字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改
2，按存值个数区分：
3，按可变不可变区分：
4，按访问顺序区分：
九、运算符
1，身份运算
#身份运算（is ，is not） is比较的是id，而双等号比较的是值 毫无疑问，id若相同则值肯定相同，而值相同id则不一定相同 >>> x=1234567890 >>> y=1234567890 >>> x == y True >>> id(x),id(y) (3581040, 31550448) >>> x is y False