day1.python基础上

1.字符串

1).原始在字符

在print函数要打印的字符串之前加一个r,就可以将字符串原样输出，而不必考虑其存在的转义字符，eg:

print(r"D:\windopw\demp")

2).长字符串

主要是为了解决跨行字符串，三个单引号或者三个双引号都可以

3)字符串的拼接和复制

拼接 = “+ ”：复制 = “*”，eg:

print("123"+"123")"""123123"""
print("每天早上起来说三遍：你好啊\n"*3)

4)陌生运算符：

运算符	作用
is	判断两个对象的id是否相等
is not	判断两个对象的id是否不相等

5)导入随机数模块

improt random
"""生成a到b的随机数"""
random.randint(a,b)
"""对随机数进行复现：先获取随机数种子"""
x = random.getstate()
"""
先执行几次
random.randint(1,9)
3
random.randint(1,9)
3
random.randint(1,9)
4
random.randint(1,9)
"""
"""重新设置随机数种子"""
random.setstate(x)
"""会发现功能之前的一模一样：
random.randint(1,9)
3
random.randint(1,9)
3
random.randint(1,9)
4
"""

6）处理字符串的函数

1. 关于字符串大小写字母转换的方法

• capitalize()：返回首字母大写
• casefold：返回所有字母都是小写的字符串
• title()：将字符串内每个连续字母的首字母大写，其余小写
• swapcase()：返回所有字母大小写翻转的字符串
• upper()：返回所有字母全都大写
• lower()：返回所有字母都小写

2. 关于字符串左中右对齐的方法

• center(width,fillchar=“”):width小于原字符串的宽度，直接原样输出；width大于原字符串的宽度，才居中对齐
• ljust(width,fillchar=‘’)：同理，width大于原字符串的宽度才左对齐
• rjust(width,fillcher=‘’)：同理，width大于原字符串的宽度才右对齐
• zfill(width)：用零填充左侧

3. 关于字符串查找的方法

• count(sub[,start[,end]]):查找子字符串在字符串中出现的次数
• find(sub[,start[,end]])：从左往右查找子字符串在字符串总的索引下标值，找不到返回-1
• rfind(sub[,start[,end]])：从右往左查找子字符串在字符串总的索引下标值，找不到返回-1
• index(sub[,start[,end]])：从左往右查找子字符串在字符串总的索引下标值，找不到报错
• rindex(sub[,start[,end]])：从右往左查找子字符串在字符串总的索引下标值，找不到报错

4. 关于字符串替换的方法

• expandtabs([tabsize=8]):使用空格来替换制表符，返回一个新的字符串

• replace(old,new,count=-1)：返回一个将所有old参数指定的子字符串替换为new参数指定的新字符串，count参数指定的是替换的次数

• translate(table)：返回一个根据table参数转换后的新字符串，table指的是用于转换规则的表格，表格获取：str.maketrans(x[,y[,z]]),该方法还有第三个参数，将指定的字符串给忽略

5. 关于字符串的判断和检测的方法

• startswith(prefix[,strart[,end]]):用于判断该参数的指定的字符串是否出现在起始位置，参数支持以元组的形式传入，以在元组中匹配可能的开头

• endswith(suffix[,start[,end]]):判断参数指定的字符串是否在结束位置，参数支持以元组的形式传入，以在元组中匹配可能的结尾

• istitle()；判断一个字符串中所有单词是否都是以大写开头，其余字母均为小写

• isupper():判断一个字符串中是否所有字母都是大写

• isalpha():判断字符串中是否只由字母构成

• isspace():检测是不是空白字符串，注意：tab、空格、\n都是空白字符

• isprintable()判断字符串中是否所有字符都是可以打印的，注意：转义字符并不可打印输出

• isdecimal():判断十进制数字

• isdigit():判断十进制数字，幂之类的，范围稍广

• isnumeric():判断十进制数字、中文数字、罗马数字等，范围更广

• isalnum():只要isalpha()、isdecimal()、isdigit()、isnumeric()返回true，结果都是true

• isidentifier():判断字符串是否是一个合法的标识符

  拓展：判断一个字符串是否为python保留标识符可以用keyword模块的iskeyword函数

6. 关于字符串截取的方法

• lstrip(chars =None)：返回删掉左侧空白的字符串，都可以传入一个字符串，按照这个字符串的每个字符去查找被查找字符串中的字符，然后剔除掉
• rstrip(chars =None):返回去除右侧的空白，都可以传入一个字符串，按照这个字符串的每个字符去查找被查找字符串中的字符，然后剔除掉
• strip(chars =None):左右的空白都去掉，都可以传入一个字符串，按照这个字符串的每个字符去查找被查找字符串中的字符，然后剔除掉
• 如果只需要剔除一个具体的字符串可以用：
  • removeprefix():指定删除的前缀
  • removesuffixe(suffix)：指定删除的后缀

7. 关于字符串的拆分和拼接方法

• partition(sep):从左到右，将字符串以参数指定的分割符为依据进行切割，并且将切割后的结果返回一个三个元素的元组，左侧是分割符左边的内容，中间是分隔符，右侧是分割符右侧的内容
• rpartition(se)：从右到左，将字符串以参数指定的分割符为依据进行切割，并且将切割后的结果返回一个三个元素的元组，左侧是分割符左边的内容，中间是分隔符，右侧是分割符右侧的内容
• split(sep=None.maxsplit=-1 )::从左到右，根据传入的分隔符将字符串拆分成列表，默认情况下是以空格来分割，返回一个列表。第二参数是指定分割的次数，默认值为-1，表示是要有分割符的地方就拆分
• rsplit(sep=None.maxsplit=-1):从右往左，根据传入的分隔符将字符串拆分成列表，第二参数是指定分割的次数，默认值为-1，表示是要有分割符的地方就拆分
• splitlines(keepends=False):将字符串按行进行分割，并且将结果以列表的形式返回，参数keepends是指定结果是否包含这个换行符；注意：不同的操作系统下表示换行的转义字符是不一样的，例如：Linux的是\n,MAC的是\r,Windows的是\r\n
• join(iterable):以被调用的字符串作为分割符填充在参数中的多个字符之间，注意：当参与的拼接的元素规模级别达到百万级别以上的时候，join方法明显高于加号拼接的字符串

8. 关于格式化字符串的方法：在字符串中包含变量

   使用format（）方法：“{关键字/下标索引 ： }”

   x = 19
   print("我今年{}岁啦".format(x))
   

   花括号里面还可以写索引下标（参数当做元组），表示要使用哪一个参数

   花括号中还可以使用关键字，来表明使用哪一个参数

   "{name}今年{age}岁啦".format(name="小明",age=18)
   

   位置关键字和索引关键字也可以结合起来使用：

   "{0}是名字叫{name}的人留下的".format('这束花',name="小明")
   

   注：在格式化的字符串里面如何输出一对括号？

   • 使用另一对花括号包裹
   • 在后面变量赋值“{}”

   "{},{{}},{}".format(1,2)
   ##'1,{},2'
   "{},{},{}".format(1,"{}",2)
   ##'1,{},2'
   

   花括号里面的可选参数：

   [ [fill] align] [sign] [#] [0] [width] [group_option] [.precision] [type]

   1. 参数可选项[align]

      值	含义
      “<”	强制字符串在可用空间内左对齐（默认）
      “>”	强制字符串在可用空间内右对齐
      “=”	强制将填充放置在符号（如果有）之后，但要在数字之前的位置（例如："+000000001230"的形式打印字符串）
      “^”	强制字符串在可用空间内居中

   2. [width]表示添加空白字符的宽度

      "{2:<10},{0:^20},{1:>10}".format('枯藤老树昏鸦','古道西风瘦马','小桥流水人家')
      ##'小桥流水人家    ,       枯藤老树昏鸦       ,    古道西风瘦马'
      

   3. [0]表示为数字类型启用感知正负号0的填充效果，只对数字有效

      "{:05}".format(-100)
      '-0100'
      "{1:$<5}{0:%>10}".format(-10,200)
      '200$$%%%%%%%-10'
      "{:0=10}".format(-100)
      '-000000100'
      

   4. [sign]:仅对数字类型有效，千分符

      值	含义
      “+”	整数前面添加正号+，复数前面添加负号-
      “-”	只有负数才在前面添加负号-，默认情况
      空格	在正数前面添加一个空格，负数前面添加负号-

   	"{:+} {:-}".format(100,200)
   	'+100 200'
   	"{:,}".format(1234456678)
   	'1,234,456,678'
   	## 当位数不够时，千分符不会显示
   	"{:_}".format(123)
   	'123'
   	"{:_}".format(123456)
   	'123_456'
   

   5. [precision]精度

      • 对于[type] 设置为‘f’或者‘F’的浮点数来说，是限定小数点后显示多少个数位

      • 对于[tyep]设置为‘g’或者‘G’的浮点数来说，是限定小数点前后一共显示多少位

      • 对于非数字类型来说，限定的是最大字段大小

      • 对于整数来说，则不允许使用该[precision]选项，会报错

      "{:.7f}".format(3.141592658432)
      '3.1415927'
      "{:.4g}".format(3.141592658432)
      '3.142'
      "{:.4}".format("hello world")
      'hell'
      "{:.3}".format(10)
      

   6. [type]选项：决定了数据应当如何来呈现

      值	含义
      b	将参数以二进制的形式输出
      c	将参数以unicode字符的形式输出
      d	将参数以十进制的形式输出
      o	将参数以八进制的形式输出
      x	将参数以十六进制的形式输出
      X	将参数以十六进制的形式输出
      n	跟d类似，不同指挥处在于它会使用单签语言环境设置的分隔符插入到恰当的位置
      None	跟‘d’类似

      整数和浮点数

      值	含义
      e	将参数以科学记数法的形式输出（以字母‘e’来表示指数，默认精度为6）
      E	将参数以科学记数法的形式输出（以字母‘E’来表示指数，默认精度为6）
      f	将参数以定点表示发的形式输出（不是一个是用nan表示，无穷用Inf表示，默认精度为6）
      F	将参数以定点表示发的形式输出（不是一个是用NAN表示，无穷用INF表示，默认精度为6）
      g	通用格式，小数以’f形式输出，大数以’e’的形式输出
      G	通用格式，小数以’F’形式输出，大数以’E’的形式输出
      n	跟’g’类似，不同之处在于它会使用当前语言环境设置的分隔符插入到恰当的位置
      %	以百分比的形式输出（将数字乘以100并显示为定点表示法( ‘f’）的形式，后面附带一个百分号
      None	类似于g,不同之处在于使用定点表示法时，小数点后将默认显示1位，默认精度跟给定值所需精度一致

      "{:e}".format(3.141592652)
      ##'3.141593e+00'
      "{:E}".format(3.141592652)
      ##'3.141593E+00'
      "{:f}".format(3.141592652)
      ##'3.141593'
      "{:.4f}".format(3.141592652)
      ##'3.1416'
      "{:%}".format(3.141592652)
      ##'314.159265%'
      "{:.2%}".format(0.525)
      ##'52.50%'
      

   7. [#]选项：

      参数以二进制、八进制或者十六进制在字符串中输出的时候，它会自动追加一个前缀

      "{:b}".format(8)
      ##'1000'
      "{:c}".format(16)
      ##'\x10'
      "{:d}".format(16)
      ##'16'
      "{:o}".format(16)
      ##'20'
      "{:x}".format(16)
      ##'10'
      "{:#b}".format(8)
      ##'0b1000'
      "{:#o}".format(16)
      ##'0o20'
      

   8. 通过关键字参数来设置选项的值

      "{:.{pre}g}".format(3.1415,pre=2)
      ##'3.1'
      "{:{fill}{align}{width}.{prec}{type}}".format(3.1415,fill="+",align="^",width=10,prec=3,type="g")
      ##'+++3.14+++'
      

9. f-字符串（f-string）(python3.6版本及其以上才能使用)，因此大多数情况下format方法是更加适用的

   f"{12.3:,}"
   ##'12.3'
   f"{3.14159265832:,}"
   ##'3.14159265832'
   f"{314159265832:,}"
   ##'314,159,265,832'
   F"{3.14159265832:E}"
   ##'3.141593E+00'
   name = '小明'
   age = 19
   f"{name}的年龄是{age}"
   ##'小明的年龄是19'
   fill="+"
   align="^"
   width=10
   prec=3
   ty = "g"
   ##f"{3.14159:{fill}{align}{width}.{prec}{ty}}"
   '+++3.14+++'
   

2.循环和分支

1. 分支语句

	res = int(input("请属于一个整数："))
		print("输入的值合格") if res>=0 else print("输入的值不合格")
	    if res<=10:
	        print("这个整数小于10")
	    elif res<=20:
	        print("这个整数在10——20")
	    else:
	        print("这个整数大于20")

条件语句：执行 a if 条件 else 执行b

2. 循环语句

break,continue都存在，作用跟其他高级语言是一样的，都只能作用于一次循环。python里面只有while和for

1. while

		while counts>0:
			循环体
			counts = counts-1

2. for

语法结构：

		##for 变量 in 迭代对象：
		##	循环体
		
		string = 'hello world'
		for item in string:
		   print(item,end='\n')
		
		##i = 0
		## while i<len(string):
		   ##  print(string[i])
		   ##  i += 1

可迭代对象有：字符串、列表

for一般搭配range 函数使用，range函数：生成一个数字序列，用法：

		range(stop)
		range(start,stop)
		rnage(start,stop,step)

注意：range函数包括起始start，不包括终止stop

3. 数字类型

• 整数：整数长度是不受限制的

• 浮点数：python和C语言类型，都是采用IEEE754的标准来存储浮点数的，所以会产生一定的精度误差

  	i=0
  	while i<1:
  	    i = i+0.1
  	    print(i)
  	"""
  	0.1
  	0.2
  	0.30000000000000004
  	0.4
  	0.5
  	0.6
  	0.7
  	0.7999999999999999
  	0.8999999999999999
  	0.9999999999999999
  	1.0999999999999999
  	"""

因此：注意：浮点数的比较，因此如何来精确的计算浮点数呢？

这里要用到一个decimal的模块,然后用decimal.Decimal()来实例化一个对象

  	import decimal
  	a = decimal.Decimal("0.1")
  	b = decimal.Decimal("0.2")
  	print(a + b)
  	"""0.3"""
  	c = decimal.Decimal("0.3")
  	print(a + b == c)
  	"""True"""

• 复数:1+2j,无论是实部还是虚部，他们都是以浮点数的形式存放的，eg:

  x = 1 + 2j
  """获取虚部"""
  x.real
  1.0
  """获取虚部"""
  x.imag
  2.0
  

4. 数字运算

表达式	作用
x//y	确保两个数相除的结果是一个整数，如果不是整数，就向下取整
x%y	x除以y的余数
abs(x)	求x的绝对值
int(x)	将x转成整数
float（x）	将x转成浮点数
complex(real,imag)/complex(x)	返回一个复试，real是实部，imag是虚部/将x转换为复数
x.conjugate()	返回x的共轭复数
divmod(x,y)	返回（x//y,x%y）
pow(x,y)/pow(x,y,z)	计算x的y次方/会将x与y幂运算的结果对z取余
x ** y	计算x的y次方

5. 布尔类型

bool（）函数，结果为False的情况有：

• 定义为False的对象：None和False
• 值为0的数字类型：0,0.0,0j,Decimal(0)，Fraction(0,1)[分子为0，分母为1的有理数]
• 空的序列和集合：“”,(),{},[],set(),range(0)

1. 布尔运算符

运算符	作用
and	and = &&
or	or = ||
not	not =-

python中任何对象都能直接进行真值测试（测试该对象的布尔类型值为True或者False),用于if或者while语句的条件判断，也可以作为布尔逻辑运算符的操作数。

2. or /and 的短路逻辑

短路逻辑的核心思想是：从做往右，只有的那个第一个操作数的值无法确定逻辑运算的结果时，才对第二个操作数进行求值，eg:

  	0 and 4
  	"""结果为：0，因为and的逻辑是两边为True才是True,现在第一个的结果已经为Fasle，那么结果肯定为False，就直接抛出第一个数"""
  	3 and 4
  	"""结果为4，因为第一个结果为True,因此还要对后面的结果进行波尔运算才能最终确定布尔运算的值，因此返回的是第二个值"""
  	3 or 4
  	"""结果为3，因为第一个已经确定为True了，or是只要一个为True时，整个逻辑运算的结果已经确定了，所以直接返回第一个"""
  	0 or 4
  	"""4"""

3.运算符的优先级

优先级（从低到高）	运算符	含义
1	lambda	Lamda表达式
2	if-else	条件表达式
3	or	布尔“或”
4	and	布尔“与”
5	not x	布尔“非”
6	in, not in ,is,is not,<,<=,>,>=,!=,==	成员测试，同一性测试，比较
7	|	按位或
8	^	按位异或
9	&	按位与
10	<<,>>	移位
11	+，-	加法，减法
12	*，@，/,//,%	乘法，矩阵乘法，除法，地板除，取余数
13	+x,-x,~x	正号，负号，按位翻转
14	**	指数
15	await x	Await 表达式
16	x[index],x[index,index],x(arguments…),x.attribute	下标，切片，函数调用，属性调用
17	（expressions…）,[expressions…],{key:value…},{expressions}	绑定或元组显示，列表显示，字典显示，集合显示

4.列表

可以存放不同类型的元素,格式：[元素1，元素2，…]。 列表跟数组类型，通过下标取值

列表从做往右 从0开始，从右往左从-1开始

	元素次序	1	2	3	4
从左往右	下标	0	1	2	3
从右往左	下标	-4	-3	-2	-1

1. 列表操作

• 列表切片

  格式：list[起始：终止：跨度值]

		## 获取前3个值
		list = [1,2,3,"a",[1,2]]
		list[0:3]##[1, 2, 3]
		list[:3]##[1, 2, 3]
		list[3:]##['a', [1, 2]]
		list[:]##[1, 2, 3, 'a', [1, 2]]
		##跳着输出
		list[1::2]##[2, 'a']
		##倒着来
		list[::-1]##[[1, 2], 'a', 3, 2, 1]

2. 增删改查

• 增：

  append（）,在列表末尾添加一个指定的元素

  extend()方法，将新的内容追加到原列表最后一个元素的后面。注意，extend的参数必须是一个可迭代对象

  insert(位置索引，待插入的元素)方法，

• 删：

  remove(待删除的元素)方法，

  • ​ 注意：如果列表多个待删除的元素，俺么它只会删除第一个
  • 如果待删除的元素不存在，那么程序将报错

  pop（待删除的下标）方法，弹出指定的元素

  clear()函数，清除整个列表元素

• 改：

  数组[下标] = 新值

  数组[:3] = [‘index1’,‘index2’] ，将列表第三个后面的数替换为等号右边的列表

  sort（key=None,reverse=False）函数，对列表中的元素进行原地排序（key参数用于指定一个用于比较的函数，reverse参数用于指定排序的结果是否翻转）

  reverse()函数，在原列表中逆置列表中的元素

• 查：

  count(待计数的元素)函数，对列表中查找元素的个数

  index(待查找元素的值，start,stop),指定查找开始结束位置段，查找列表中某个元素的索引值,如果有多个相同值，就返回找的第一个值的下标

  copy()函数，用来复制一个列表

3. 列表的乘法和加法

列表间的加法 ：为两个列表的拼接

列表的乘以n：将列表里的元素重复n次

4. 列表的浅拷贝和深拷贝

• 浅拷贝

  使用copy函数和列表切片的方式都能实现拷贝

  x = [1,2,3]
  y = x.copy()
  x[0] = 3
  y
  [1, 2, 3]
  

  Tip:浅拷贝只是拷贝了外层对象，当列表嵌套时，拷贝只是拷贝了引用

• 深拷贝

  引入copy模块来实现深拷贝

  import copy
  x = [[1,2,3],[4,5,6],[7,8,9]]
  y = copy.copy(x);
  x[1][1] = 0
  print(x)
  print(y)
  x = [[1,2,3],[4,5,6],[7,8,9]]
  y = copy.deepcopy(x)
  x[1][1] = 0
  print(x)
  print(y)
  ##[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
  ##[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
  ##[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
  ##[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
  

5. 列表推导式

格式：expression(表达式) for target in iterable

演示代码：

x =  [1,2,3,4,5,7]
y = [i*2 for i in x]
print(x)
z = [i for i in range(10)]
print(z)
codes_list = [ord(i) for i in 'hello world']
print(codes_list)
##将矩阵第二列的元素提取出来
maxtrix = [
    [1,2,3],
    [4,5,6],
    [7,8,9]
    ]
new_matrix = [i[1] for i in maxtrix]
print(new_matrix)
## 从矩阵中获取对角线元素
m1 = [maxtrix[i][i] for i in range(3)]
print(m1)
## 获取矩阵副对角线上的值
m2 = [maxtrix[i][len(maxtrix)-1-i] for i in range(3)]
print(m2)
##用列表推导式创建一个二维列表
print("用列表推导式创建一个二维列表")
matrix1 = [[0]*3 for i in range(3)]
print(matrix1)

列表推导式其实还可以添加一个用于筛选的if分句：

## 删选出其中以字母F开头的单词
new_list = [item for item in lists if item[0] == 'F']
print(new_list)

6. 列表推导式嵌套

   格式： [expression for target1 in iterable for target2 in iterable2 for target3 in iterable3…for targetN in iterableN]

   ##将二维数组降维为一维数组
   
   maxtrix = [[1,2,3],[4,5,6],[7,8,9]]
   print(maxtrix)
   print("用列表推导式降维：",[col for row in maxtrix for col in row])
   ## 还可以使用不同的迭代对象
   print([a+b for a in "HELLO" for b in "hello"])
   print([[x,y] for x in range(10) if x%2 == 0 for y in range(10) if y%3 == 0])
   
   

   重要的程序设计原则kiss(Keep It Simple & Stupid)：简洁独立，尽管列表推导式运行时间比起循环实现的运行时间更短，但过分复杂的列表推导式会导致代码维护成本增加。

5.元组

元组是既可以像字符串那样可以容纳不同类型的变量，又拥有字符串不可更改的特性

1. 元祖与列表形式上的差异：

​ 列表：[元素1，元素2，…]

​ 元组：（元素1，元素2，…）

a = (90,2,345,566,2,41,3)

2. 元组也可以通过下标来获取元素：第一个是a[0],最后一个是a[-1]

3. 元组也支持切片操作:

a[:3]
##(90, 2, 345)
a[::-1]
##(3, 41, 2, 566, 345, 2, 90)

4. 由于元组不可改变的性质，所以元组只支持查操作：

• index()方法
• count()方法

a.index(90)
##0
a.count(566)
##1

5. 加号和乘号字在元组中也是可以使用的,即拼接和重复

   a*3
   ##(90, 2, 345, 566, 2, 41, 3, 90, 2, 345, 566, 2, 41, 3, 90, 2, 345, 566, 2, 41, 3)
   b =(123,456,90)
   a+b
   ##(90, 2, 345, 566, 2, 41, 3, 123, 456, 90)
   

6. 元组的嵌套：用“,”即可

   c =a,b
   c
   ##((90, 2, 345, 566, 2, 41, 3), (123, 456, 90))
   c = (a,b)
   c
   ##((90, 2, 345, 566, 2, 41, 3), (123, 456, 90))
   

7. 元组也可以迭代，因此列表推导式也适用于元组，但生成的是列表

   c
   ##((90, 2, 345, 566, 2, 41, 3), (123, 456, 90))
   for i in c:
       for j in i:
           print(j)
   [col for row in c for col in row ]
   ##[90, 2, 345, 566, 2, 41, 3, 123, 456, 90]
   [row[::-1] for row in c]
   ##[(3, 41, 2, 566, 345, 2, 90), (90, 456, 123)]
   

8. 圆括号的必要性

   在不会引起歧义的情况下，python是允许你省略掉元组的圆括号的,生成只有一个元素的元组：a =（1,）

9. 打包和解包

生成一个元组，称为打包，将元组内部元素一次性复制给变量名的行为称为解包

x,y = c
x
##(90, 2, 345, 566, 2, 41, 3)
y
##(123, 456, 90)
a1,a2,a3,a4 = "Hell"
a1
##'H'
a3
##'l'
a4
##'l'
b1,b2,*b3 = "hell world"
b1
##'h'
b2
##'e'
b3
##['l', 'l', ' ', 'w', 'o', 'r', 'l', 'd']

注意：无论使用那一种序列的解包，赋值号左边的变量名和数值右边的变量名要个数相同;python的多重赋值就是先将会元组进行打包，然后在将元组进行解包

6.序列

列表、元素和字符串似乎有很多共同点：

1. 都可以通过下标索引的方式获取元素
2. 第一个元素的索引值都是0
3. 都可以通过切片的方法获取到一个范围内元素的集合
4. 都有很对共同的运算符

python把它们统称为序列，根据是否可修改，将序列分为可变序列和不可变序列,列表就是典型的可变序列，而字符串和元组都是不可变序列

1. 能够作用于序列的运算符

• ”+“和”*“号，即拼接和重复

  增量赋值：在赋值的过程中同时进行计算,注意点：可变序列进行增量赋值后还是原来的标识，而不可变序列进行增量赋值后是新的标识

  x = [1,2,3]
  id(x)
  ##1271064659200
  x *= 2
  id(x)
  ##1271064659200
  

  在python中每一个对象都有三个基本属性：唯一标识、类型和值，id()函数的作用就是返回一个代表指定对象的唯一标识符的整数值，

  可以用is 和 is not来检测对象的id值是否相等，从而来判断是否是同一个对象

• in和not in 运算符是用于判断是否包含/不包含在序列中

• del语句用于删除一个或多个指定的对象，除此之外，还可以删除可变序列中的指定元素

  x ="String"
  y = [1,2,3]
  del x,y
  x
  ##name 'x' is not defined
  y
  ##name 'y' is not defined
  x = [1,2,3,4,5,6,7,8,9]
  del x[1]    
  x
  ##[1, 3, 4, 5, 6, 7, 8, 9]
  del x[0]      
  x     
  ##[3, 4, 5, 6, 7, 8, 9]
  ##还可以结合切片来实现
  del x[1:4]      
  x      
  ##[3, 7, 8, 9]
  ## 例如实现列表的clear()函数的功能
  del x[:]
  

2. 能够作用于序列的函数，也是可迭代对象中相关的大部分函数

函数格式	作用
list（）	将可迭代对象转换为列表
tuple()	将可迭代对象转换为元组
str()	将可迭代对象转换为字符串
min(iterable,* [,key,default])、min(arg1,arg2.args[,key]) &max(iterable, * [,key,default)、max(arg1,arg2.*args[,key])	对比传入的参数，并且返回最大值和最小值,如果传入的字符串的话比较的是每个字符的编码值，default参数可以设置默认传入参数;第二种使用方式是传入多个参数，min和max函数就自动找出最大值和最小值
len()&sum()	len（）函数的参数不能超过运行平台的最大范围2**32 -1/2 * * 64-1,sum函数计算求和sum(被求和序列，start=100),表示从100开始累加
sorted(key,reverse)&reversed()	sorted()函数时返回的是一排好序的全新列表,而列表的sort函数时列表原地排序如果传入的是字符串的话就会从字符串第一个字符进行编码值的比较；key是一个敢于排序算法的函数，其值在使用的时候只写函数名,然后python在排序过程中会将每一个元素去自动调用key所对应的函数，然后比较key对应的函数的返回结果；reversed（）函数返回的是一个参数迭代器
all()&any()	all()函数判断可迭代对象中是否所有元素都为真，any（）元素判断可迭代对象中是否某个对象为真
enumerate()	该函数用于返回一个枚举对象，他的功能就是将可迭代对象中的每个元素及从开始的序号，共同构成一个二元组的列表
zip（）（拉链函数）	该函数用于创建一个聚合多个可迭代对象的迭代器。它会将作为参数传入的每个可迭代独享的每个元素依次组合成元组，即第i个元组包含来自每个参数的第i个元素；如果传入的可迭代对象长度不相等，那么按照最短的聚合，多的部分会被删除。如果想保留被删除的部分，这里可以使用一个叫itertools模块的zip_longest()函数
map（）	该函数会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将返回运算结果的迭代器;当传入的可跌代对象长度不相等时，会在最短的可迭代独享终止前结束
filer()	该函数会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将运算结果为真的元素，以迭代器的形式返回。

a = ['a','c','d']
enumerate(a)
##<enumerate object at 0x0000017AA90B8E80>
list(enumerate(a))
##[(0, 'a'), (1, 'c'), (2, 'd')]
list(enumerate(a,10))
##[(10, 'a'), (11, 'c'), (12, 'd')]
x = [1,2,3]
y=[4,5,6]
z=[7,8,9]
zipped = zip(x,y,z)
zipped
##<zip object at 0x0000017AAAE02B80>
list(zipped)
##[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
z = "hello"
list(zip(x,y,z))
##[(1, 4, 'h'), (2, 5, 'e'), (3, 6, 'l')]
import itertools
zipped =itertools.zip_longest(x,y,z)
list(zipped)
##[(1, 4, 'h'), (2, 5, 'e'), (3, 6, 'l'), (None, None, 'l'), (None, None, 'o')]
mapped =map(ord,"hello")
list(mapped)
##[104, 101, 108, 108, 111]
mapped = map(pow,[1,2,3],[3,2,1])
list(mapped)
##[1, 4, 3]
list(map(min,[1,2,3],[0,4,5,6],[10,4,5,6,4]))
##[0, 2, 3]
list(filter(str.islower,"hello"))
##['h', 'e', 'l', 'l', 'o']
list(filter(str.islower,"HeLLo"))
##['e', 'o']

3. 迭代器和可迭代对象

   一个迭代器肯定是一个可迭代对象,迭代器和可迭代的对象之间的区别：

   1.可迭代对象可以重复使用，而迭代器则是一次性的

   mapped = map(ord,"hello")
   for i in mapped:
       print(i)
   
   ##104
   ##101
   ##108
   ##108
   ##111
   list(mapped)
   ##[]
   

   2.如何将迭代对象变为迭代器呢？

   iter():可以将迭代对象变为迭代器

   x = [1,3,2,3,5]
   y =iter(x)
   type(y)
   ##<class 'list_iterator'>
   

   3.针对迭代器的函数

   ​ next（iterator,当迭代器中没有元素了就显示第二个参数）函数：逐个将迭代器中的元素给提取出来

   z =iter(x)
   next(z,-1)
   1
   next(z,-1)
   3
   next(z,-1)
   2
   next(z,-1)
   3
   next(z,-1)
   5
   next(z,-1)
   -1
   next(z,-1)
   -1
   

7.字典dict

字典是python中唯一实现映射关系的内置类型;

1. 什么是映射关系呢？

   就跟函数类似，一个输入对应一个输出，映射的两边是一一对应的

2. 字典的构成

   格式：{键：值}/{key : value}

   与序列不同的是：序列是通过位置的偏移来存取数据的，而字典则是通过键俩实现写入和读取的，eg:x[key]

3. 字典的创建方式

   1. 直接使用大括号和冒号的形式声明：

      student = {"name":'小张',"age":18,"address":'北京'}
      

   2. 使用dict（）函数构建，这种写法键不能加引号

      b = dict(name='小张', age= 18, address='北京')
      

   3. 使用列表作为dict函数的参数，其中列表的元素二元组

      c= dict([('name','小张'), ('age',18), ('address','北京')])
      

      tip:因此可以使用zip函数快速生成一个符合条件的列表，来快速生成字典

      a = ["name","age","address"]
      b=["小张",18,"北京"]
      c = list(zip(a,b))
      d = dict(c)
      d
      ##{'name': '小张', 'age': 18, 'address': '北京'}
      

   4. 将第一种方法作为参数，传递给dict（）函数

   5. dict函数的参数，混合的方式：

      d = dict({"name":"小张","age":18,"address":'北京'}，sex='男')
      

   6. 直接用zip来构造dict()的参数：、

      f = dict(zip(["name","age","address"],["小张",18,'北京']))
      

4. 字典的增删改查

   • 增

     dict.fromkeys(iterable[,values]):该函数可以使用iterable指定的可迭代对象来创建一个新的字典，适用于从无到有快速初始化一个字典

     d = dict.fromkeys("hello",10)
     d
     {'h': 10, 'e': 10, 'l': 10, 'o': 10}
     d['w'] = 11
     d
     {'h': 10, 'e': 10, 'l': 10, 'o': 10, 'w': 11}
     

   • 删

     • pop(被抛出元素，default=“”):删除字典中指定元素

     • popitem():ppython3.7之前是随机删除一个键值对，3.7之后删除的是最后一个加入字典的键值对

     • clear()：清空字典

   • 改

     • updateI():更新字典的多个键

     d = dict.fromkeys("hello")
     d
     ##{'h': None, 'e': None, 'l': None, 'o': None}
     d['h'] = 113
     d
     ##{'h': 113, 'e': None, 'l': None, 'o': None}
     d.update({'e':120,'o':130,'w':145})
     d
     ##{'h': 113, 'e': 120, 'l': None, 'o': 130, 'w': 145}
     

   • 查

     • 通过键查找，但找不到会报错

     • get(key[,default]):查找某个键，找不到返回默认值

     • setdefault(key[,default]):查找某键是否在字典中，如果在就返回它的值，如不过不在就给它指定一个新的值

       d
       ##{'h': 113, 'e': 120, 'l': None, 'o': 130, 'w': 145}
       d.get('h')
       ##113
       d.get('H',"没有")
       ##'没有'
       d.setdefault('H',118)
       ##118
       d
       ##{'h': 113, 'e': 120, 'l': None, 'o': 130, 'w': 145, 'H': 118}
       

     • items():获取字典的键值对视图对象

     • keys():获取字典的键视图对象

     • values():获取字典的值视图对象

       视图对象：视图对象即字典的动态视图，这意味着当字典的内容发生改变时，视图对象的内容也会响应地跟着改变

       keys = d.keys()
       values = d.values()
       item = d.items()
       keys
       ##dict_keys(['h', 'e', 'l', 'o', 'w', 'H'])
       values
       ##dict_values([113, 120, None, 130, 145, 118])
       item
       ##dict_items([('h', 113), ('e', 120), ('l', None), ('o', 130), ('w', 145), ('H', 118)])
       d.pop('H')
       ##118
       keys
       ##dict_keys(['h', 'e', 'l', 'o', 'w'])
       values
       ##dict_values([113, 120, None, 130, 145])
       item
       ##dict_items([('h', 113), ('e', 120), ('l', None), ('o', 130), ('w', 145)])
       

     • copy方法：实现浅拷贝

   • 其他函数

     • len()函数：获取键值对的数量

     • in 和 not in ：判断某个元素是否在字典里面

     • liist(dict)：将字典转换为所有键构成的列表，list(d.values())

     • iter():将字典的键构成一个迭代器

     • python3.8之后的函数可以使用reversed函数：对字典内部的键值对进行逆向操作

       len(d)
       5
       'h' in d
       True
       'H' not in d
       True
       list(d)
       ['h', 'e', 'l', 'o', 'w']
       list(d.values())
       [113, 120, None, 130, 145]
       list(reversed(d))
       ['w', 'o', 'l', 'e', 'h']
       

5. 字典的嵌套

   d = {'name':{'nikname':'小红','formalName':'张红'},'age':{'realAge':48,'virtualAge':18}}
   d['age']['realAge']
   ##48
   d = {'name':['小红','张红'],'age':[48,18]}
   d['age'][0]
   ##48
   

6. 字典推导式

   z = {v:k for v,k in d.items() if 'g' not in v }
   z
   {'name': ['小红', '张红']}
   

8.集合set

跟字典一样，集合中的元素也是唯一的，并且是无序的

1. 创建集合的方法

• 花括号来声明

• 集合推导式

• set()函数构造

  a = {"name","age","address"}
  b={i for i in ["name","age","address"]}
  b
  ##{'age', 'name', 'address'}
  c=set("helloworld")
  c
  ##{'r', 'o', 'h', 'd', 'w', 'e', 'l'}
  

2. 访问集合中的元素

• in 、not in :判断某元素是否在集合中

• for循环

  'c' not in c
  ##True
  'l' in c
  ##True
  for i in c:
      print(i)  
  """
  r
  o
  h
  d
  w
  e
  l"""
  

3. 集合的唯一性

• 利用集合实现去重的操作

  set([1,2,34,1,2])
  ##{1, 2, 34}
  ##利用集合判断是否存在重复元素
  x = [1,2,34,1,2]
  len(x) == len(set(x))
  ##False
  

4. 集合相关的函数

函数名	作用
s.copy()	返回s 集合的一个浅拷贝
s.isdisjoint(other)	如果s 集合中没有与other迭代对象存在共同的元素，那么返回True，否则返回 False
s.issubset(other)	如果s集合是 other容器的子集，那么返回True，否则返回False
s.issuperset(other)	如果s集合是other 容器的超集)，那么返回True，否则返回False;超集：B中的元素全在A中，且A包含B，称A为B的超集
s.union(*others)	返回一个新集合，其内容是s 集合与others容器的并集,可以传入多个参数
s.intersection(*others)	返回一个新集合，其内容是s集合与others容器的交集,可以传入多个参数
s.difference(*others)	返回一个新集合，其内容是存在于s集合中，但不存在于others容器中的元素（差集）,可以传入多个参数
s.symmetric_difference(other)	返回一个新集合，其内容是排除掉s集合和other容器中共有的元素后，剩余的所有元素（对称差集），只支持一个参数

s = set('helloworld')
s
##{'r', 'o', 'h', 'd', 'w', 'e', 'l'}
s.isdisjoint(set('python'))
##False
s.isdisjoint('python')
##False
s.isdisjoint("C++")
##True
s.issubset('hellworld,python!')
##True
s.issuperset('hellworld,python!')
##False
s.issuperset('hellworld')
##True
s.union({4,5,6})
##{4, 5, 'r', 'o', 6, 'h', 'd', 'w', 'e', 'l'}
s.intersection('python')
##{'h', 'o'}
s.difference("python")
##{'w', 'e', 'r', 'l', 'd'}
## 上面的方法都支持多参数的
s.union({1,2,3},{4,5,6})
##{1, 2, 3, 4, 5, 'r', 'o', 6, 'h', 'd', 'w', 'e', 'l'}
s.intersection('python','json')
##{'o'}
s.difference('python','josn')
##{'w', 'e', 'r', 'l', 'd'}
s.symmetric_difference('python')
##{'y', 'r', 't', 'd', 'w', 'e', 'p', 'l', 'n'}

Tips:运算符也能表示集合之间的关系，注意：使用运算符，那么两边都必须是集合才行，不然就会报错

运算符	等价的关系
a<b	a是b的真子集
a<=b	a是b的子集
a>b	a是b的真超集
a>=b	a是b的超集
a | b	a与b的并集
a & b	a与b的交集
a - b	a与b的差集
a ^ b	a与b的对称差集

5. 可变(set)和不可变集合(frozenst)

   1. 仅适用于set对象的方法，对集合中的内容进行改动的方法

      方法名	作用
      update(*others)	使用others参数指定的值来更新集合，为迭代器的参数的每一个字符都会更新到字典里面
      intersection_update(*others)	用集合们的交集更新原集合
      difference_update( *others)	用集合们的差集更新原集合
      symmetric_difference_update(others)	用集合们的对称差更新原集合
      add(ele)	只给集合添加一个元素,
      remove()、discard()	如果指定删除的元素不存在，前者remove抛出异常 ，后者会静默处理
      pop()	随机弹出一个元素
      clear()	清空集合

      Tips:使用函数参数others表示可以使用多个参数，other表示只能使用一个参数

      f  = frozenset('hello')
      f
      ##frozenset({'e', 'l', 'h', 'o'})
      s = set('hello')
      s
      ##{'e', 'l', 'h', 'o'}
      s.update([1,2.3,34,4],"world")
      s = set('hello')
      s.difference_update("python")
      s
      ##{'l', 'e'}
      s.symmetric_difference_update("hello")
      s
      ##{'h', 'o'}
      s.add('w')
      s
      ##{'h', 'w', 'o'}
      

6. 可哈希

   通过hash(object)函数可以获取一个函数的哈希值，python中大多数不可变的对象都是可哈希的，而可变的对象是不可哈希的；

   只有可哈希的对象才可以作为字典的键以及集合的元素