day6.细说类型2

一.字符串
（一）字符串需要掌握的操作
1.
# strip  (清除)：序列是一段字符串，该函数表示从头和从尾部同时开始进行扫描，如果扫描的字符在序列字符串中，则剔除掉，一直到遇到一个不在序列字符串中的字符为止
# lstrip   ：从左边开始扫描
# rstrip   ：从右边开始扫描
#特别的情况，如果函数圆括号里面的序列字符串为空，则默认为剔除首尾部的空白（包括空格、制表符）
# msg = '!lzl真帅!!'
# print(msg.strip('!'))
# print(msg.lstrip('!'))
# print(msg.rstrip('!'))
2.
# lower :单词转小写
# upper :单词转大写
# msg = 'lzl真帅LZL66'
# print(msg.lower())
# print(msg.upper())
3、
# startswith    :检查字符串是否是以指定子字符串开头 常用环境：用于IF判断
# endswith  : 判断字符串是否以指定字符或子字符串结尾，常用于判断文件类型
# msg = 'lzl真帅LZL66'
# print(msg.startswith('lzl'))
# print(msg.endswith('66'))
4、
# format的三种玩法  :字符串格式化
# print('my name is %s ,age is %s' %('lzl',18))
#
# print('my name is {} ,age is {}'.format('lzl',18))    #依次填入
# print('my name is {x} , age is {y}'.format(y=18,x='lzl'))  #根据名字
# print('my name is {1} , age is {0}{1}'.format(18,'lzl'))   #根据索引

5、
# split (分割):用来对字符串进行分割，分割后的字符串以列表形式返回
# rsplit :从右边开始切
# msg = 'lzl :121:666'
# print(msg.split())    #默认以空格分割
# print(msg.split(':'))
# print(msg.rsplit(':',1))  #后面数字（参数）代表切的次数
6、
# join :连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串
# msg = ':'
# print(msg.join('ab'))           #字符串
# print(msg.join(('a','b')))     #元组
# print(msg.join(['a','b']))    #列表
7、
# replace (代替):把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次
# msg = 'lzl is very very good!'
# print(msg.replace('very','much',1))  #第三个参数不写，默认全部代替
8、
# isdigit  :可以判断bytes和unicode类型,是最常用的用于于判断字符是否为纯"数字"的方法
#msg = '121'
# print(msg.isdigit())
（二）需要了解的方法
1、
# find,rfind,index,rindex,count
#msg = 'lzl is very handsome'
# print(msg.find('is',0,6))  #返回字符串最后一次出现的位置，如果没有匹配项则返回 -1
# print(msg.rfind('is'))     #从右侧开始
#
# print(msg.index('is0'))  #与find一样，但没有匹配会报异常

#print(msg.count('e'))   #用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置
2、
# center,ljust,rjust,zfill
# msg = 'lzl'
# print(msg.center(20,','))           #返回一个原字符串居中,并使用空格填充至长度 width 的新字符串。默认填充字符为空格。
# print(msg.ljust(20,'*'))            #左对齐
# print(msg.rjust(20))                #右对齐
3、
# captalize,swapcase,title
# msg = 'lzl LZL'
# print(msg.capitalize())  #使第一个字符大写，其余字符小写。（捕获）
# print(msg.swapcase())    #对字符串的大小写字母进行转换  (交换盒）
# print(msg.title())      #所有单词都是以大写开始，其余字母均为小写 (标题）
4、
 is数字系列
# num1=b'4' #bytes
# num2='4'  # 阿拉伯数字
# num3='四' #中文数字
# num4='Ⅳ' #罗马数字
# isdigit :变量值是字节串或字符串类型并且包含的阿拉伯数字，isdigit()结果才为真  （数字）
# print(num1.isdigit())
# print(num2.isdigit())
# print(num3.isdigit())
# print(num4.isdigit())
# isdecimal  :变量值是字符串类型并且包含的阿拉伯数字，isdecimal()结果才为真  (十进制）
# print(num2.isdecimal())
# print(num3.isdecimal())
# print(num4.isdecimal())
# isnumeric  :变量值是字符串类型并且包含的阿拉伯数字\中文数字\罗马数字，isnumeric()结果才为真  (数值）
# print(num2.isnumeric())
# print(num3.isnumeric())
# print(num4.isnumeric())
5、
# is其他
# msg = 'lzl121'
# print(msg.isalnum())  #字符串由字母或数字组成
# print(msg.isalpha())  #字符串只由字母组成
# print(msg.isascii()) #如果字符串中的所有字符都是ASCII，则返回True，否则返回False。

总结： 存一个值，有序，不可变
二.列表
 1、用途：按位置存放多个值

 2、定义方式：在[]内用逗号分割开多个任意类型的元素
# l = [11,3.3,"xx",[1111,2222]]  # l = list(。。。)
# print(type(l))

# list数据类型转换: 所有可以被for循环遍历的类型都可以传给list然后转换成列表
# print(list("abc"))
# print(list({"k1":111,"k2":222}))

# res=list(range(5))
# print(res)

（一）列表需要优先掌握的操作
1、
# 按索引存取值(正向存取+反向存取)：即可存也可以取
# list = [11,'bb',22]
# print(list[0])
# print(list[-1])
#
# list[1] = 'aa'
# print(list)
# list[3] = 5    # 不可以用不存在的索引赋值
2、
# 切片(顾头不顾尾，步长)
# list = [11,'bb',22]
# print(list[:])
#
# list2 = list[:]   #浅拷贝
# print(list2)
#
# print(list[::2])  #步长

3、
# 长度
# list = [11,'bb',22]
# print(len(list))   #列表里元素的长度
4、
# 成员运算in和not in
# list = [11,'aa','bb',5]
# print(5 in list)
# print('s' not in list)
5、
# 追加
# list = ['aa','bb',5]
# x = list.append('cc')
# print(list)
# print(x)
#
# list.insert(1,55)   #在指定位置追加
# print(list)

6、
# 删除
# list = ['a','bb',3,'4']
(1),单纯的删除 ==》没有返回值
# del list[2]    #根据列表索引删除
# print(list)
# list.remove('4')  #根据列表元素删除
# print(list)
（2）
# 取走-》有返回值
# res = list.pop(1)
# print(list)   #根据索引取
# print(res)

7、
# 循环
# list = [11,22,'aa']
# for x in list:
#     print(x)
（二）需要掌握的操作
1.
# count   :用于统计某个元素在列表中出现的次数
# list1 = [111,222,333,333,333,444,555]
# print(list1.count(333))
2.
#reverse :用于反向列表中元素  (颠倒.反向)
# list1 = [111,222,333,333,333,444,555]
# list1.reverse()
# print(list1)
3.
#clear  :清空列表
#append  ：添加列表
# list1 = [111,222,333,333,333,444,555]
# list1.clear()
# print(list1)
# list1.append([666,777,888])
# print(list1)

4.
#列表追加多个元素
# list1 = [111,222,333,333,333,444,555]
#
# for x in [666,777,888]:    #遍历依次添加
#     list1.append(x)
# print(list1)
#
# list1.extend([666,777,888])  #用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
# print(list1)
5.
#copy  :浅拷贝 用于复制列表，类似于 a[:]
# list1 = [111,222,333,333,333,444,555]
# print(list1.copy())
6.
# index  :用于从列表中找出某个值第一个匹配项的索引位置
# list1 = [111,222,777,888,999,333,333,333,444,555]
# res = list1.index(333)
# print(res)
7.
#  sort :用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数
# list1 = [111,222,777,888,999,333,333,333,444,555]
# list1.sort(reverse=True)   #reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
# print(list1)
总结：  存多个值  有序  可变
三.元组
 1、用途：

 2、定义方式：在()内用逗号分隔开多个任意类型的元素
# x = (10,)  #  x= tuple(...)
# print(x,type(x))

# tuple数据类型转换：任意能够被for循环遍历的类型都可以交给tuple转成元组
# print(tuple("hello"))

 3、常用操作+内置的方法
优先掌握的操作：
1、按索引取值(正向取+反向取)：只能取
# t = (111,222,333,[44,555])
# print(t[0])
# t[0]=6666

2、切片(顾头不顾尾，步长)
# t = (111,222,333,[44,555])
# print(t[0:3])

3、长度
# t = (111,222,333,[44,555])
# print(len(t))

4、成员运算in和not in
# t = (111,222,333,[44,555])
# print([44,555] in t)

5、循环
# t = (111,222,333,[44,555])
# for x in t:
#     print(x)

需要掌握的操作：
# t = (111,222,333,[44,555])
# x = t.index(333)  #找不到引发异常
# print(x)
# y = t.count(333)  #计数
# print(y)

总结： 存多个值  有序 不可变
四.字典
 1、用途:存一对值
 2、定义方式：在{}内用逗号分隔开多个元素，每个元素都是key:value的格式，其中value可以是任意类型
#            而key必须是不可变类型，通常是str类型，而且key不能重复
# dic = {111:6666,"k1":777,(1,2,3):8888,[1,2,3]:3333}
# dic = {111:6666,"k1":777,(1,2,3):8888,"k1":99999999}
# print(dic)
# print(dic[(1,2,3)])

# dict数据类型转换
# info = [('k1',111),('k2',222),('k3',3333)]
# dic=dict(info)
# print(dic)
#
# print(dict(x=1,y=2,z=3))
 3、常用操作+内置的方法
优先掌握的操作：
1、按key存取值：可存可取
# dic = {"name":"lzl","age":18}
# dic['gender'] = "male"
# dic['name'] = "xxxx"
# print(dic)

2、长度len
# dic = {"name":"lzl","age":18}
# print(len(dic))

3、成员运算in和not in: 以key为准
# dic = {"name":"lzl","age":18}
# print('name' in dic)

4、删除
# dic = {"name": "lzl", "age": 18}
# 单纯的删除
# del dic['name']
# print(dic)

# 取走
# v=dic.pop("name")
# print(v)

# v = dic.popitem()   #返回并删除字典中的最后一对键和值
# print(v)

5、键keys()，值values()，键值对items()
# dic = {"name": "lzl", "age": 18}
# print(dic.keys())
# # ['age', 'name']  #python2 中
# print(dic.values())
# # [18, 'lzl']
# print(dic.items())
# # [('age', 18), ('name', 'lzl')]

6、循环
# for k in dic.keys():
#     print(k)
#
# for k in dic:
#     print(k)

# for v in dic.values():
#     print(v)

# for k,v in dic.items():
#     print(k,v)

 8、get()
# dic = {"name": "lzl", "age": 18}
# print(dic['namexxxx'])
# print(dic.get("namexxxx"))

# 需要掌握的操作
# dic = {"name": "egon", "age": 18}
# dic.update({'gender':"male","age":19})
# print(dic)

# dic = {}.fromkeys(["name","age","gender"],[])
# print(dic)
# dic['name'].append(1111)
# print(dic)

# dic = {}.fromkeys(["name","age","gender"],None)

# dic = {"age": 18}
# if "name" not in dic:
#     dic['name'] = "xxx"

# v = dic.setdefault('name',"xxx")
# print(dic)
# print(v)

总结： 存多个值 无序  可变
五.集合
set基本使用
（1）关系运算
（2）去重
 2、定义方式: 在{}内用逗号分割开多个元素，需要注意的是集合的元素必须满足
#            1、集合的元素必须是不可变类型
#            2、集合的元素无序
#            3、集合的元素没有重复
# s = {}
# print(type(s)) # 空字典
# s = set()  # 定义空集合
 3、常用操作+内置的方法
 3.1
# 去重（无序）
# names = ["lzl","lzl","lzl",'lili','jack']
# res = list(set(names))
# print(res)
# 3.2
# 关系运算
# pythons = {"lzl",'lxx',"张全蛋","李铁蛋",'刘金蛋',"赵银弹"}
# linuxs = {'lili','jack','lzl','lxx','tom','kkk'}

 （1）& 交集：求既报名pyton又报名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))

# print(linuxs - pythons)

 (4) ^ 对称差集：求没有同时报名两门课程的学员
# res = (pythons - linuxs) | (linuxs - pythons)
# res = pythons ^ linuxs
# print(res)

# res = pythons.symmetric_difference(linuxs)
# print(res)

 (5) 父子集：父子指的包含与被包含的关系
#   父集：>=
#   子集：<=
# s1 = {1,2,3}
# s2 = {1,2}
# print(s1 >= s2)
# print(s1.issuperset(s2))
#
# print(s2 <= s1)
# print(s2.issubset(s1))

# s1 = {1,2,3}
# s2 = {1,2,4}
#
# print(s1 > s2)
# print(s1 < s2)

# s1 = {1,2,3}
# s2 = {1,3,2}
# print(s1 == s2)
 总结:  存多个值   无序   set集合可变,frozenset不可变集合

1.浅copy  :只拷贝一层
# l1 = [111,222,[333,444]]
# l2 = l1.copy()
# l3 = l1[:]
#
# print(id(l1[0]),id(l1[1]),id(l1[2]))
# print(id(l2[0]),id(l2[1]),id(l2[2]))
# l1[2][0] = 666
# l1[0] = 777
#
# print(l1)
# print(l2)
2、深copy  :只要有可变类型就一直拷贝，直到不可变类型
# from copy import deepcopy
#
# l1 = [111,222,[333,444]]
# l2 = deepcopy(l1)
#
# print(id(l1[0]),id(l1[1]),id(l1[2]))
# print(id(l2[0]),id(l2[1]),id(l2[2]))
#
# l1[2][0] = 666
# print(l1)
# print(l2)
#
# l1[0] = 777
# print(l1)
# print(l2)