python简笔记

---

---

列表

---

一、列表的添加（向列表添加数据，字符串等）

a = []
# todo append一次只能够添加一个值
a.append("字符串")
a.append(123)
print(a)
# 输出>>>['字符串', 123]
#     #     #  分  #     #  割  #     #     #  线  #     #     #     #     #     #     #
# todo extend一次能够添加多个值，但是这些值需要使用列表的方式添加
b = []
b.extend(["字符串", 123])
print(b)
# 输出>>>['字符串', 123]
#     #     #  分  #     #  割  #     #     #  线  #     #     #     #     #     #     #
# todo insert能够向列表指定位置插入值
c = ["字符串", 123]
c.insert(1, "在中间插入的值") # 列表计数0开始
print(c)
# 输出>>>['字符串', '在中间插入的值', 123]

二、列表的删除

# todo remove移除列表内的任意值（该值需要完全匹配，例如"字符串"）
a = [1,2,3,4,5,"字符串"]
a.remove(1)  # remove一次只能移除一个值
print(a)
# 输出>>>[2, 3, 4, 5, '字符串']
a.remove("字符串")
print(a)
# 输出>>>[2, 3, 4, 5]
# todo del移除列表内的任意位置的值
#     #     #  分  #     #  割  #     #     #  线  #     #     #     #     #     #     #
b = [1,2,3,4,5,"字符串"]
del b[0]  # del delete的缩写，一次只能移除一个指定位置的值
print(b)
# 输出>>>[2, 3, 4, 5, '字符串']
del b[4]  # 这里的4是因为上面的代码中已经移除了1，当前列表只剩下[2, 3, 4, 5, '字符串']
print(b)
# 输出>>>[2, 3, 4, 5]
# del b  # 删除整个列表，不是清空列表是删除b
#     #     #  分  #     #  割  #     #     #  线  #     #     #     #     #     #     #
# todo pop移除列表内的任意位置的值,默认移除列表中最后一个参数。
c = [1, 2, 3, 4, 5, "字符串"]
c.pop(0)  # del delete的缩写，一次只能移除一个指定位置的值
print(c)
# 输出>>>[2, 3, 4, 5, '字符串']
c.pop(4)  # 这里的4是因为上面的代码中已经移除了1，当前列表只剩下[2, 3, 4, 5, '字符串']
print(c)
# 输出>>>[2, 3, 4, 5]
c.pop()  # 不给参数即删除最后一个
print(c)
# 输出>>>[2, 3, 4]

三、列表的分片

a = [1,2,3,4,5,"字符串"]
a[4:5]  # 指定位置分片
# 输出>>>[5,"字符串"]
a[4:]  # 当开始位置指定，结束位置未指定，结束位置默认列表最后一个值
# 输出>>>["字符串"]
a[:]  # 开头结尾都不指定，默认为列表的第0个元素-列表的最后一个元素
# 输出>>>[1,2,3,4,5,"字符串"]

四、count列表元素统计

a = [1, 2, 3]
b = a * 3
print(b)  # 输出>>>[1, 2, 3, 1, 2, 3, 1, 2, 3]
# 统计2这个元素在b列表中出现多少次
print(b.count(2))  # 输出>>>3

五、index返回参数在列表中的位置

a = [1, 2, 3, 1, 2, 3, 1, 2, 3]
print(a.index(2))  # 输出>>>1
"""
a.index(1, 2, 4)中，
1代表需要查找的值，2代表在列表中需要找的起始位置，4代表结束位置
不给2，4参数，默认从0开始
"""
print(a.index(1, 2, 4))  # 输出>>>3

六、reverse反转列表

a = [1, 2, 3, 1, 2, 3, 1, 2, 3]
a.reverse()  
print(a)  # 输出>>>[3, 2, 1, 3, 2, 1, 3, 2, 1]

七、sort列表排列

a = [1, 2, 3, 4, 5, 3, 1, 2, 3]
a.sort()  # 默认从小到大排序
print(a)  # 输出>>>[1, 1, 2, 2, 3, 3, 3, 4, 5]
a.sort(reverse=True)  # 从大到小排序
print(a)  # 输出>>>[5, 4, 3, 3, 3, 2, 2, 1, 1]

八、列表的拷贝

a = [1, 2, 3, 4, 5, 3, 1, 2, 3]
b = a[:]  # 使用分片的方式拷贝
print(b)  # 输出>>>[1, 2, 3, 4, 5, 3, 1, 2, 3]
c = a
print(a)  # 输出>>>[1, 2, 3, 4, 5, 3, 1, 2, 3]
a.sort()
print("a = %s\nc = %s\nb = %s\n" % (a, c, b))
# 输出>>>a = [1, 1, 2, 2, 3, 3, 3, 4, 5]
# 输出>>>c = [1, 1, 2, 2, 3, 3, 3, 4, 5]
# 输出>>>b = [1, 2, 3, 4, 5, 3, 1, 2, 3]
# todo 当我们把a列表排序后，发现c列表也随之变化，而b列表未变化
# todo b列表相当于复制了一份a列表，而c相当于在a列表中添加了个(索引)标签

---

元组

---

一、元组的认识

a = (1, 2, 3, 4, "字符串")  # todo python识别元组的标志是“,”
b = 1, 2, 3, 4, "字符串"    # todo 也可将元组写成这样
c = ()  # 空元组
print("a = %s\nb = %s\n" % (a, b))  
# 输出>>>a = (1, 2, 3, 4, '字符串')
# 输出>>>b = (1, 2, 3, 4, '字符串')

二、元组的修改（添加与删除）

a = (1, 2, 3, 4, "字符串")  # todo python识别元组的标志是“,”
b = 1, 2, 3, 4, "字符串"    # todo 也可将元组写成这样
a = a[:2] + ("这是添加的字符",) + a[2:]   # 添加元素
b = b[:2] + b[3:]  # 删除元素
print("a = %s\nb = %s\n" % (a, b))
# 输出>>>a = (1, 2, '这是添加的字符', 3, 4, '字符串')
# 输出>>>b = (1, 2, 4, '字符串')

三、元组相关操作符

c = ("一", 2)
d = c * 3
print(d)
# 输出>>>('一', 2, '一', 2, '一', 2)

---

字符串

---

一、转义字符串

# \(在行尾时)	续行符
# \\	反斜杠符号
# \'	单引号
# \"	双引号
# \a	响铃
# \b	退格(Backspace)
# \e	转义
# \000	空
# \n	换行
# \v	纵向制表符
# \t	横向制表符
# \r	回车
# \f	换页
# \oyy	八进制数，yy代表的字符，例如：\o12代表换行
# \xyy	十六进制数，yy代表的字符，例如：\x0a代表换行
# \other	其它的字符以普通格式输出

二、字符串运算符

a = "Hello"
b = "Python"
# +	字符串连接
print(a + b)
# 输出>>>HelloPython
#     #     #  分  #     #  割  #     #     #  线  #     #     #     #     #     #     #
# *	重复输出字符串
print(a * 2)
# 输出>>>HelloHello
#     #     #  分  #     #  割  #     #     #  线  #     #     #     #     #     #     #
# []	通过索引获取字符串中字符
print(a[1])
# 输出>>>e
#     #     #  分  #     #  割  #     #     #  线  #     #     #     #     #     #     #
# [ : ]	截取字符串中的一部分
print(a[1:4])
# 输出>>>ell
#     #     #  分  #     #  割  #     #     #  线  #     #     #     #     #     #     #
# in	成员运算符 - 如果字符串中包含给定的字符返回 True
print("H" in a)
# 输出>>>True
#     #     #  分  #     #  割  #     #     #  线  #     #     #     #     #     #     #
# not in	成员运算符 - 如果字符串中不包含给定的字符返回 True
print("M" not in a)
# 输出>>>True
#     #     #  分  #     #  割  #     #     #  线  #     #     #     #     #     #     #
# r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。
print(r'\n')
# 输出>>>\n
print(R'\n')
# 输出>>>\n 
#     #     #  分  #     #  割  #     #     #  线  #     #     #     #     #     #     #
# %	格式字符串(接字符串格式化内容）

三、字符串格式化

# %c	 格式化字符及其ASCII码
# # %s	 格式化字符串
# # %d	 格式化整数
# # %u	 格式化无符号整型
# # %o	 格式化无符号八进制数
# # %x	 格式化无符号十六进制数
# # %X	 格式化无符号十六进制数（大写）
# # %f	 格式化浮点数字，可指定小数点后的精度
# # %e	 用科学计数法格式化浮点数
# # %E	 作用同%e，用科学计数法格式化浮点数
# # %g	 %f和%e的简写
# # %G	 %F 和 %E 的简写
# # %p	 用十六进制数格式化变量的地址
#     #     #  分  #     #  割  #     #     #  线  #     #     #     #     #     #     #

""" # todo 格式化操作符辅助指令"""

# *	定义宽度或者小数点精度
# -	用做左对齐
# +	在正数前面显示加号( + )
# <sp>	在正数前面显示空格
# #	在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
# 0	显示的数字前面填充'0'而不是默认的空格
# %	'%%'输出一个单一的'%'
# (var)	映射变量(字典参数)
# m.n.	m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

四、字符串内置函数

string.capitalize()
把字符串的第一个字符大写

string.center(width)
返回一个原字符串居中,并使用空格填充至长度 width 的新字符串

string.count(str, beg=0, end=len(string))
返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

string.decode(encoding='UTF-8', errors='strict')
以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除非 errors 指
定 的 是 'ignore' 或 者'replace'

string.encode(encoding='UTF-8', errors='strict')
以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'

string.endswith(obj, beg=0, end=len(string))
检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.

string.expandtabs(tabsize=8)
把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。

string.find(str, beg=0, end=len(string))
检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1

string.format()
格式化字符串 
举例：
a, b, c, d = "{} b {}", "{a} 2 {b}", "{0:.1f}{1}", "{{}} b {{}}"
print(a.format("a", "c"), b.format(a=1, b=3), c.format(9.55, "kg"), d.format(a, c))  # 数字也可以，数字可不加引号
# todo a中将a,c顺序加入到a字符串中，b中，指定加入的字符位置，c中":"格式化字符串9.55（保留一位小数,d中{{}}大括号内已经被转义所以后面插入的a,c不生效

string.index(str, beg=0, end=len(string))
跟find()方法一样，只不过如果str不在 string中会报一个异常.

string.isalnum()
如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False

string.isalpha()
如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False

string.isdecimal()
如果 string 只包含十进制数字则返回 True 否则返回 False.

string.isdigit()
如果 string 只包含数字则返回 True 否则返回 False.

string.islower()
如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

string.isnumeric()
如果 string 中只包含数字字符，则返回 True，否则返回 False

string.isspace()
如果 string 中只包含空格，则返回 True，否则返回 False.

string.istitle()
如果 string 是标题化的(见 title())则返回 True，否则返回 False

string.isupper()
如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

string.join(seq)
以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

string.ljust(width)
返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串

string.lower()
转换 string 中所有大写字符为小写.

string.lstrip()
截掉 string 左边的空格

string.maketrans(intab, outtab])
maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，
第二个参数也是字符串表示转换的目标。

max(str)
返回字符串 str 中最大的字母。

min(str)
返回字符串 str 中最小的字母。

string.partition(str)
有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组
(string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.

string.replace(str1, str2,  num=string.count(str1))
把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.

string.rfind(str, beg=0,end=len(string) )
类似于 find()函数，不过是从右边开始查找.

string.rindex( str, beg=0,end=len(string))
类似于 index()，不过是从右边开始.

string.rjust(width)
返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串

string.rpartition(str)
类似于 partition()函数,不过是从右边开始查找

string.rstrip()
删除 string 字符串末尾的空格.

string.split(str="", num=string.count(str))
以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+ 个子字符串

string.splitlines([keepends])
按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，
不包含换行符，如果为 True，则保留换行符。

string.startswith(obj, beg=0,end=len(string))
检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.

string.strip([obj])
在 string 上执行 lstrip()和 rstrip()

string.swapcase()
翻转 string 中的大小写

string.title()
返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())

string.translate(str, del="")
根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中

string.upper()
转换 string 中的小写字母为大写

string.zfill(width)
返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0

#------------------------------------------------------------------------------#
#									示例
#				（平时不建议这样编写代码，违背python简洁之道）
# （每个字母和后面对应顺序的字符串相对应a,b = "12","34" 等价于a = "12" b = "34")
#------------------------------------------------------------------------------#
a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, \
    A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P = \
    "test首字母大写a", "居中b", "1213出现次数c", "指定编码格式d", "是否以**结尾e", "12\t12f",\
    "检查1g", "{} b {}h", "检查2i", "检查字符是否都是字母或数字j", "检查字母k", "123l", "321m",\
    "n", "o", "p", "q", "r", "s", "tTESt", "  u", "vtesT", "wW", "xX", "y", "z", "Aa", "Bb",\
    "C", "Dd", "E  ", "FfF", "G", "H", "Ii\t\n\r\r\n", "J", " Kk ", "Ll", "mM", "N3", "oO", "P"
print(
      a.capitalize(), "\n",  # 把字符串的第一个字符大写
      b.center(5), "\n",  # 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
      c.count("1"), "\n",  # 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
      d.encode(encoding="UTF-8", errors="strict"), "\n",  # 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
      e.endswith("**结尾"), "\n",  # 检查字符串是否以XX结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
      f.expandtabs(tabsize=2), "\n",  # 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。
      g.find("检查"), "\n",  # 检测str是否在str中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
      h.format("a", "c"), "\n",  # 格式化字符串(详细规则请阅读上文format函数下举例
      i.index("检查2"), "\n",  # 跟find()方法一样，只不过如果str不在 string中会报一个异常.
      j.isalnum(), "\n",  # 如果 str至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
      k.isalpha(), "\n",  # 如果 str至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
      k.isdecimal(), "\n",  # 如果 str只包含十进制数字则返回 True 否则返回 False.
      l.isdigit(), "\n",  # 如果 str只包含数字则返回 True 否则返回 False.
      m.islower(), "\n",  # 如果 str中包含至少一个区分大小写的字符，并且所有这些字符都是小写，则返回 True，否则返回 False
      n.isnumeric(), "\n",  # 如果 str中只包含数字字符，则返回 True，否则返回 False
      o.isspace(), "\n",  # 如果 str中只包含空格，则返回 True，否则返回 False.
      p.istitle(), "\n",  # 如果 str是标题化的(见 title())则返回 True，否则返回 False
      q.isupper(), "\n",  # 如果 str中包含至少一个区分大小写的字符，并且所有这些字符都是大写，则返回 True，否则返回 False
      r.join("添加"), "\n",  # 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
      s.ljust(20), "\n",  # 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
      t.lower(), "\n",  # 转换 string 中所有大写字符为小写
      u.lstrip(), "\n",  # 截掉 string 左边的空格
      v.maketrans(t, v), "\n",  # maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，
                                # 第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
      max(w), "\n",  # 返回字符串 str 中最大的字母。
      min(x), "\n",  # 返回字符串 str 中最小的字母。
      y.partition(y), "\n",  # 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元
                             # 素 的 元 组(string_pre_str,str,string_post_str),
                             # 如果 string 中不包含str 则 string_pre_str == string.
      z.replace(z, y), "\n",  # .replace(str1,str2,num=str.count(str1))把str中的str1替换成str2如果num指定,替换不超过num次
      A.rfind("a"), "\n",  # 类似于 find()函数，不过是从右边开始查找
      B.rindex("b"), "\n",  # 类似于 index()，不过是从右边开始.
      C.rjust(3), "\n",  # 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
      D.rpartition("D"), "\n",  # 类似于 partition()函数,不过是从右边开始查找
      E.rstrip(), "\n",  # 删除 string 字符串末尾的空格.
      F.split("f"), "\n",  # 以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+ 个子字符串
      I.splitlines(False), "\n",  # 按('\r','\r\n',\n')分隔，返回包含各行作为元素的列表.参数False不包含换行符True则保留换行符
      J.startswith("J"), "\n",  # 检查字符串是否以obj开头是则返回True，否则返回False。如果beg 和 end 指定值，则在指定范围内检查.
      K.strip(), "\n",  # 在 str 上执行 lstrip()和 rstrip()
      L.swapcase(), "\n",  # 翻转 string 中的大小写
      M.title(), "\n",  # 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
      N.translate("N"), "\n",  # 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中
      O.upper(), "\n",  # 转换 string 中的小写字母为大写
      P.zfill(5), "\n",  # 返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0
      )
#------------------------------------------------------------------------------#
#									结果输出
#------------------------------------------------------------------------------# 
"""
Test首字母大写a 
  居中b  
 2 
 b'\xe6\x8c\x87\xe5\xae\x9a\xe7\xbc\x96\xe7\xa0\x81\xe6\xa0\xbc\xe5\xbc\x8fd' 
 False 
 12  12f 
 0 
 a b ch 
 0 
 True 
 True 
 False 
 False 
 True 
 False 
 False 
 False 
 False 
 添r加 
 s                    
 ttest 
 u 
 {116: 84, 84: 116, 69: 101, 83: 115} 
 w 
 X 
 ('', 'y', '') 
 y 
 1 
 1 
   C 
 ('', 'D', 'd') 
 E 
 ['F', 'F'] 
 ['Ii\t', '', ''] 
 True 
 Kk 
 lL 
 Mm 
 N3 
 OO 
 0000P 
 """

特殊函数：format

a, b, c, d = "{0} B {1} D {2}", "{a} B {c} D {e}", "{0} B {c} D {e}", "{0} B {c} D {e}"
print(a.format("A", "C", "E"), "\n",  # 当 format 里面的值没有指定时默认按照顺序排
      b.format(a="A", c="C", e="E"), "\n",  # 当format 中指定了顺序则按照指定顺序
      c.format("A", c="C", e="E"), "\n",   # 可用数字默认和字母指定混用 todo 但是数字要在字母前
      d.format("A", e="C", c="E"), "\n")  # 与c对比当format中指定顺序错位，则值错位
e = "{0:.1f}{1}"  # 在替换域中，冒号表示格式化字符的开始,.1表示保留一位小数,f为定点数（类似浮点数）
print(e.format(1.11, "kg"))  

五、字符串格式化符号

一、格式化符号的含义

"""
%c	格式化字符及其 ASCII 码
%s	格式化字符串
%d	格式化整数
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同 %e，用科学计数法格式化浮点数
%g	根据值的大小决定使用 %f 或 %e
%G	作用同 %g，根据值的大小决定使用 %f 或者 %E
"""
#------------------------------------------------------------------------------#
#									示例
#				（平时不建议这样编写代码，违背python简洁之道）
# （每个字母和后面对应顺序的字符串相对应a,b = "12","34" 等价于a = "12" b = "34")
#------------------------------------------------------------------------------#
a, b, c, d, e, f, g, h = (97, 98, 99, 100), "Test",\
                         (5, 5, 5+5), 10, 180, 5.111,\
                         2000, 200
print("%c, %c, %c, %c" % a, "\n",# 格式化字符串及其ASCⅡ码
      "%s" % b, "\n",  # 格式化字符串
      "%d + %d = %d" % c, "\n",  # 格式化整数
      "%o" % d, "\n",  # 格式化无符号八进制数
      "%x" % e, "\n",  # 格式化十六进制数
      "%X" % e, "\n",  # 格式化十六进制数
      "%f" % f, "\n",  # 格式化定点数，可指定小数点后的精度
      "%e" % g, "\n",  # 用科学计数法格式化定点数
      "%E" % g, "\n",  # 用科学计数法格式化定点数
      "%g" % h, "\n",  # 根据大小决定使用%f或%e
      "%G" % h, "\n",  # 根据大小决定使用%f或%e
      )

二、格式化操作符辅助命令

"""
m.n	  m 是显示的最小总宽度，n 是小数点后的位数
-     用于左对齐
+     在正数前面显示加号（+）
#  	  在八进制数前面显示 '0o'，在十六进制数前面显示 '0x' 或 '0X'
0     显示的数字前面填充 '0' 取代空格
"""
a, b = 5.111, 100
print("%10.5f" % a, "\n",  # m(10) 是显示的最小总宽度，n(5) 是小数点后的位数
      "%-10d" % a, "\n",  # 用于左对齐
      "%+d" % a, "\n",  # 在正数前面显示加号（+）
      "%#0o %#0x %#0d" % (b, b, b), "\n",  # 在八进制数前面显示 '0o'，在十六进制数前面显示 '0x' 或 '0X'
      "%010d %-010d" % (b, b), "\n",  # 显示的数字前面填充 '0' 取代空格
      )

三、转义字符及其含义

"""
\'	单引号
\"	双引号
\a	发出系统响铃声
\b	退格符
\n	换行符
\t	横向制表符（TAB）
\v	纵向制表符
\r	回车符
\f	换页符
\o	八进制数代表的字符
\x	十六进制数代表的字符
\0	表示一个空字符
\\	反斜杠
"""

---

序列

---

一、几种常见的内置函数

""" List()把一个可迭代对象转换为列表"""
a = "I Love China"
print(list(a))
# 输出>>>['I', ' ', 'L', 'o', 'v', 'e', ' ', 'C', 'h', 'i', 'n', 'a']

"""tuple([iterable])把一个可迭代对象转换为元组"""
a = [3, 2, 1], [4, 3, 2, 1]
print(tuple(a))
# 输出>>>([3, 2, 1], [4, 3, 2, 1])

"""str(obj)将一个对象转化为字符串"""
a = [3, 2, 1]
print(str(a),  "这是未转换前%s" % type(a), "这是转换后%s" % type(str(a)))
# 输出>>>[3, 2, 1]  这是未转换前<class 'list'>  这是转换后<class 'str'>

"""len(obj)显示一个字符串的长度"""
a, b, c = "I Love China", [3, 2, 1, 4, 3, 2, 1], {"A": 1, "B": 2}
print(len(a), len(b), len(c))
# 输出>>>12 7 2

"""max()/min()返回序列或参数集合中的最大值/最小值"""
# todo 在排序中按照ASCII码排序进行
a, b, c = "I Love China", [3, 4, 3, -2, 1], {"A": 1, "B": 2}
print("这是max的输出%s" % [max(a), max(b), max(c)])
print("这是min的输出%s" % [min(a), min(b), min(c)])
# 输出>>>这是max的输出['v', 4, 'B']
# 输出>>>这是min的输出[' ', -2, 'A']

"""sum(iterable[, start=0])返回序列iterable和可选参数start的总和"""
a, b = [3, 4, 3, -2.5, 1], (3, 4, 3, -2.5, 1)
print(sum(a), sum(b))
# 输出>>>8.5 8.5

"""reversed()反转"""
a = [3, 4, 3, -2.5, 1]
print(list(reversed(a)))
# 输出>>>[1, -2.5, 3, 4, 3]

"""enumerate()将列表中的每个值都转换成元组"""
a, b, c = "Cna", [2, 1, 4], {"A": 1, "B": 2}
print(list(enumerate(a)), list(enumerate(b)), list(enumerate(c)))
# 输出>>>[(0, 'C'), (1, 'n'), (2, 'a')] [(0, 2), (1, 1), (2, 4)] [(0, 'A'), (1, 'B')]

"""zip返回各个参数返回的序列，然后组成元组"""
a, b = "Cna", [2, 1, 4]
print(list(zip(a, b)))
# 输出>>>[('C', 2), ('n', 1), ('a', 4)]

---

函数

---

一、创建函数

# 创建第一个python函数

def create_function(name="函数", value=1, a=2, b=3):  # todo def的上下都要空两行
    """这是函数注释。使用（函数名.__doc__查看）
    name="函数", value=1, a=2, b=3这些是默认值"""
    print("这是第%d个%s" % (value, name))
    return a + b


print(create_function(), "\n-------------------")  # 这是在不给参数的情况下，使用默认值的结果
print(create_function(name="Python函数", value=1, a=2, b=3), "\n-------------------")  # 这是在给参数的情况下的结果
print(create_function.__doc__)  # 查看函数注释
# 输出>>>这是第1个函数
# 输出>>>5
# 输出>>>-------------------
# 输出>>>这是第1个Python函数
# 输出>>>5
# 输出>>>-------------------
# 输出>>>这是函数注释。使用（函数名.__doc__查看）
# 输出>>>    name="函数", value=1, a=2, b=3这些是默认值
"""---------------------------------------------------------
							注释
函数定义过程中的name、value、a、b叫形参，因为它只是一个形式，表示占据一个参数位置
return中的a, b叫做实参，它是具体的值(同理return上面的print的value,name同理
下面的print中的create_function("Python函数", 1, 2, 3)叫实参，它也是具体的值
---------------------------------------------------------"""

（形参）默认参数

def default_parameters(name=0):
    """这里面的name=1就是默认参数。默认参数可以在调用函数时不用给参数，也避免了无参数导致的报错"""
    print(name)


"""括号为空时使用默认参数，括号为1时按照默认顺序赋值，括号为name=2时按指定参数赋值"""
default_parameters(), default_parameters(1), default_parameters(name=2)
print(default_parameters.__doc__)  # todo .__doc__查看函数注释

（形参）可变参数

"""------------------------------------
  # todo 这是单一可变参数举例
------------------------------------"""
def variable_parameters(*a):
    """这是单一可变参数举例"""
    print("这是可变参数:", a)


variable_parameters("可以使用字符串、数字、列表、字典、元组等作为传参")  # 这是给一个参数
variable_parameters(1, ["列表1", "列表2"], {"字典1": 1, "字典2": 2}, ("元组1", "元组2"))  # 这是给多个参数


"""------------------------------------
  # todo 这是多值可变参数举例
------------------------------------"""
def variable_parameters2(*b, name="这是name的默认值", value=""):
    """这是多值可变参数举例"""
    print(b, name, value)


variable_parameters2(["这是可变参数的值1"], ("这是可变参数的值", 2))  # 只给可变参数传参时
variable_parameters2(1, name="这是name参数的新值", value="这是value参数的新值")  # 分别给可变参数、name、value分别传参时
variable_parameters2(name="这是name参数的新值", value="这是value参数的新值")  # 将可变参数缺省时
print(variable_parameters.__doc__, variable_parameters2.__doc__)

局部变量和全局变量

def local_variable():
    b = 2  # 这里可以理解为局部变量
    print("这里是函数内部调用外部变量a时打印出a的结果a=%s" % a)  # 在函数里面可以调用全局变量
    print("这里是函数内部调用内部变量b时打印出b的结果b=%s" % b)


a = 1  # 这个就可以理解为全局变量
try:  # todo 这里用尝试的方法来打印b  这里可以百度一下python忽略错误
    """这里使用忽略错误的方式来打印局部变量的情况"""
    print(b)
except Exception as A:  # todo 如果上面try(尝试运行)有错误，则执行下面的语句，否则不执行（类似if 和 else)
    print("当print(b)出错时，打印这段话", "因为print(b) %s" % A)
    print("----------分--------------割-------------线--------------")

print(a)
print("下面打印的是调用函数打印的结果")
print(local_variable())
# 输出>>>当print(b)出错时，打印这段话 因为print(b) name 'b' is not defined
# 输出>>>----------分--------------割-------------线--------------
# 输出>>>1
# 输出>>>下面打印的是调用函数打印的结果
# 输出>>>这里是函数内部调用外部变量a时打印出a的结果a=1
# 输出>>>这里是函数内部调用内部变量b时打印出b的结果b=2
# 输出>>>None

在函数内部修改全局变量的值

a = 1


def MyFun():
    a = 2
    print("此时a的地址为%s,a=%s" % (id(a), a))


def MyFun1():
    print("此时a的地址为%s,a=%s。从这里可以看出MyFun中对a值的修改并没有在MyFun1中产生影响" % (id(a), a))


def MyFun2():
    global a
    a = 2
    print("此时a的地址为%s,a=%s" % (id(a), a))


def MyFun3():
    print("此时a的地址为%s,a=%s。从这里可以看出MyFun2中对a值的修改已经在MyFun3中改变了a的地址" % (id(a), a))


MyFun()
MyFun1()
print("----------分--------------割-------------线--------------")
MyFun2()
MyFun3()
# 输出>>>此时a的地址为140716128641456,a=2
# 输出>>>此时a的地址为140716128641424,a=1。从这里可以看出MyFun中对a值的修改并没有在MyFun1中产生影响
# 输出>>>----------分--------------割-------------线--------------
# 输出>>>此时a的地址为140716128641456,a=2
# 输出>>>此时a的地址为140716128641456,a=2。这里可以看出MyFun2中对a值的修改已经在MyFun3中改变了a的地址

函数的内嵌及调用

def fun1():
    print("这是fun1函数的打印")
   
    def fun2():
        print("这是fun2函数的打印")
    fun2()  # 这里其实是在fun1函数中调用的fun2，注意它和fun1中的print对齐，所以不在fun2函数内部。


fun1()
# 输出>>>这是fun1函数的打印
# 输出>>>这是fun2函数的打印

"""在函数内部修改函数外部变量。关键字：nonlocal """
def fun3():
    x = [5]
    y = 5
    def fun4():
        nonlocal y
        x[0] *= x[0]  # 这里没有将x设为函数fun2的外部变量，而是将x以列表的形式调用
        y *= y   # 这里通过nonlocal将y强制访问。来进行修改
        return x[0], y
    return fun4()


print(fun3())
# 输出>>>(25, 25)

lambda函数表达式（简单函数简写）

"""使用lambda表达式可以省去函数的定义过程，在程序执行完成后Python会自动删除
https://blog.csdn.net/zjuxsl/article/details/79437563
这篇文章写的比较好"""
valueab = lambda a, b: a + b
print(valueab(100, 10))
# 输出>>>110

filter（过滤函数）

"""filter(function or None, iterable)函数参数"""
def odd(x):
    """筛选出偶数"""
    return x % 2


temp = range(20)
show = filter(odd, temp)
print(list(show))

# todo 这里是用filter和lambda组合，将上述函数简化为下面代码
print(list(filter(lambda x: x % 2, range(20))))
# 输出>>>[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
# 输出>>>[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

map(映射函数）

"""同上面的过滤函数类似"""
"""将0-20中的每个值乘以2后输出"""
print(list(map(lambda x: x * 2, range(20))))
# 输出>>>[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38]

二、函数递归

'''
https://www.cnblogs.com/JerryZao/p/9531951.html 题库搜索
问题简述：一只小猴子吃桃子的问题。
话说，一只小猴子第一天摘下若干个桃子，并吃了一半。
感觉到吃的还不瘾，于是又多吃了一个；
第二天早上，又将剩下的桃子吃掉一半，又多吃了一个。
以后每天早上,都吃了前一天剩下的一半零一个。
python问题：
请问，到了第10天早上想再吃时，却发现只剩下一个桃子了。
求第一天共摘了多少？

#逆向思维
s2 = 1
for day in range(9,0,-1):
    s1 = (s2 + 1)*2
    s2 = s1
print(s1)
'''
# no 1
def foo(n=10, a=1): # n = 10 是因为 当n = 2的时候已经是答案了，但是此时的 获取不到a 要等 n==1 的时候去获取a
    if n == 1:
        return a
    a = (a + 1) * 2
    return  foo(n-1, a)

print((foo(10))) # 1534

# no 2    n只是一个循环条件
def foo(n=10):
    if n == 1:
        return 1
    return (foo(n-1) + 1) * 2

print(foo())

def foo(n=1):
    if n == 10:
        return 1
    return (foo(n+1) + 1) * 2

print(foo())

字典

一、创建字典

"""字典的创建"""
dict1 = {1: '一', 2: '二', 3: '三', 4: '四'}  # 创建字典，方式为{key:value}
for a, b, c in zip(dict1.keys(), dict1.values(), dict1.items()):
    """使用zip函数可以在for循环中循环多个值"""
    """字典中的keys,values分别对应的是字典的键值"""
    print("这是key(键)", a, "这是value", "(值)", b, "这是字典每项内容", c)
# 输出>>>这是key(键) 1 这是value (值) 一 这是字典每项内容 (1, '一')
# 输出>>>这是key(键) 2 这是value (值) 二 这是字典每项内容 (2, '二')
# 输出>>>这是key(键) 3 这是value (值) 三 这是字典每项内容 (3, '三')
# 输出>>>这是key(键) 4 这是value (值) 四 这是字典每项内容 (4, '四')
# todo 也可以这样写字典
dict2 = dict(((2, '二'), (3, "三")))
dict3 = dict(([2, '贰'], [3, '叁']))
print(dict2[2], dict3[3])
# 输出>>>二 叁

二、添加键值到字典中

dict1 = {1: '一', 2: '二', 3: '三', 4: '四'}
print(dict1)
dict1['5'] = '这是添加的值'
print(dict1)
# 输出>>>{1: '一', 2: '二', 3: '三', 4: '四'}
# 输出>>>{1: '一', 2: '二', 3: '三', 4: '四', '5': '这是添加的值'}

dict1 = {1: '一', 2: '二', 3: '三', 4: '四'}
"""setdefault()函数和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。"""
print(dict1)
print(dict1.setdefault(5))  # 这里的value缺省后，key在字典的值为None
print(dict1.setdefault(6, '六'))  # 这里的value指定后，key在字典的值为指定值
print(dict1)
print(dict1.setdefault(1))  # 这是是相当于查询字典里面key所对应的value
# 输出>>>{1: '一', 2: '二', 3: '三', 4: '四'}  # 这是原始字典打印
# 输出>>>None # 这是通过setdefault函数添加key为5且value缺省时打印
# 输出>>>六 # 这是通过setdefault函数添加key为6且value指定时打印
# 输出>>>{1: '一', 2: '二', 3: '三', 4: '四', 5: None, 6: '六'} # 打印变更后的字典
# 输出>>>一 # 查找字典中key为1时所对应的value值
# 输出>>>{1: '一', 2: '二', 3: '三', 4: '四', 5: None, 6: '六'} # 打印字典

三、改变字典中的键所对应的值

dict1 = {1: '一', 2: '二', 3: '三', 4: '四'}
print(dict1)
dict1[4] = '这是改变的值'
print(dict1)
# 输出>>>{1: '一', 2: '二', 3: '三', 4: '四'}
# 输出>>>{1: '一', 2: '二', 3: '三', 4: '这是改变的值'}

四、删除一个键所对应的值

dict1 = {1: '一', 2: '二', 3: '三', 4: '四'}
print(dict1)
del dict1[1]  # 删除一个键值
print(dict1, "此时字典中的1:'一'键值已被删除")
# 输出>>>{1: '一', 2: '二', 3: '三', 4: '四'}
# 输出>>>{2: '二', 3: '三', 4: '四'} 此时字典中的1:'一'键值已被删除

dict1 = {1: '一', 2: '二', 3: '三', 4: '四'}
print(dict1.pop(1))  # 弹出指定位置的键值
print(dict1.popitem())  # 在字典不为空的情况下，弹出最后一对键值
print(dict1)
# 输出>>>一
# 输出>>>(4, '四')
# 输出>>>{2: '二', 3: '三'}

五、清空字典

dict1 = {1: '一', 2: '二', 3: '三', 4: '四'}
print(dict1)
dict.clear(dict1)  # 清空字典
print("清空字典", dict1)
# 输出>>>{1: '一', 2: '二', 3: '三', 4: '四'}
# 输出>>>清空字典 {}=

六、删除字典（从内存中删除，后面程序无法调用）

dict1 = {1: '一', 2: '二', 3: '三', 4: '四'}
print(dict1)
del dict1  # 删除字典，后面程序再调用该字典时会报错，因为该字典在内存中已清除

"""不要这样清除字典（🤣）"""
a = {1: '一', 2: '二'}
b = a
print(a, id(a)), print(b, id(b))
a = {}
print(a, id(a)), print(b, id(b))
# 输出>>>{1: '一', 2: '二'} 2021651913448
# 输出>>>{1: '一', 2: '二'} 2021651913448
# 输出>>>{} 2021651913528  # 这里可以看到通过空列表改变，a字典已为空了
# 输出>>>{1: '一', 2: '二'} 2021651913448 # 这里能够看到b字典值依然在

七 字典的复制

"""字典 copy() 函数返回一个字典的浅复制,经过copy后的字典内存地址不相同"""
dict1 = {1: '一', 2: '二', 3: '三', 4: '四'}
dict2 = dict1.copy()
dict3 = dict2
dict3[5] = '五'
print(dict1, id(dict1))
print(dict2, id(dict2))
print(dict3, id(dict3))
# 输出>>>{1: '一', 2: '二', 3: '三', 4: '四'} 2311046961896
# 输出>>>{1: '一', 2: '二', 3: '三', 4: '四', 5: '五'} 2311046961976
# 输出>>>{1: '一', 2: '二', 3: '三', 4: '四', 5: '五'} 2311046961976

八 字典的合并（更新）

"""字典 update() 函数把字典dict2的键/值对更新到dict里。合并前后并不改变字典在内存的地址"""
dict1 = {1: '一', 2: '二', 3: '三', 4: '四'}
dict2 = {5: '五', 6: '六'}
print(dict1)
print(dict2)
dict1.update(dict2)
print(dict1)
# 输出>>>{1: '一', 2: '二', 3: '三', 4: '四'}  # dict1输出
# 输出>>>{5: '五', 6: '六'} # dict2输出
# 输出>>>{1: '一', 2: '二', 3: '三', 4: '四', 5: '五', 6: '六'} # 合并后的dict1输出

九 字典的其他方法使用

										fromkeys
					fromkeys([key],value) 创建并返回新的字典,value的值只能是一个

"""fromkeys([key],value) 创建并返回新的字典,value的值只能是一个"""
dict2 = {8: '八'}
print(dict2, id(dict2))
# 它会将dict2字典重写。从id(dict2)可以看到dict2的内存地址
print(dict2.fromkeys([1], "一"), id(dict2))  
print(dict2.fromkeys([1, 2, 3], "一"), id(dict2))
print(dict2.fromkeys([1, 2, 3], ("一", "二", "三")), id(dict2))
# 输出>>>{8: '八'} 2434944998120
# 输出>>>{1: '一'} 2434944998120
# 输出>>>{1: '一', 2: '一', 3: '一'} 2434944998120
# 输出>>>{1: ('一', '二', '三'), 2: ('一', '二', '三'), 3: ('一', '二', '三')} 2434944998120

										 get
				get(key, '自定义字符')  get可以将字典中的key进行查找,如果找到
				则返回该key所对应的value如果没有找到，则返回自定义字符。
				自定义字符也可缺省，缺省时返回None

"""get(key, '自定义字符')  get可以将字典中的key进行查找,如果找到则返回该key所对应的value
   如果没有找到，则返回自定义字符。自定义字符也可缺省，缺省时返回None"""
dict1 = {1: '一', 2: '二', 3: '三', 4: '四'}
print(dict1.get(1, "没有"))  # 查找字典中存在的key时，输出的是字典的值
print(dict1.get(5, "没有"))  # 查找字典中不存在的key时，输出的是get后的自定义字符