一、注释
1、 注释的排错性
先注释一部分代码，然后执行另外一部分代码，查看报错，用于调试。
2、注释的注意点
多行注释的嵌套：
如果外面是三个单引号，则里面要用三个双引号；如果外面是三个双引号，则里面要用三个单引号。

二、变量
1、概念：可以改变的量，具体是指内存中的一段存储空间。
house305 = “张三”
print(house305)
house305 = “李四”
print(house305)
2、变量的三种声明方式：
方式一
a = 1
b = 2
方式二
a, b = 1, 2
方式三
a = b = 3 (注意：这种方式的id(a) == id(b))

3、变量的命名规范：
字母数字下划线，首字母不能为数字。
严格区分大小写，且不能使用关键字。
变量命名有意义，且不能使用中文哦。
import keyword
print(keyword.kwlist) # [‘False’, ‘None’, ‘True’, ‘and’, ‘as’, ‘assert’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘nonlocal’, ‘not’, ‘or’, ‘pass’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]
4、变量的交换
a = 3
b = 10
a, b = b, a
print(a, b) # 10 3

三、Python的六大数据类型
分为：Number型、容器类型（字符串型、列表型、元组型、集合型、字典型）。
(1)Number数字类型(int float bool complex)
①Number类型之int 整型(正整数 0 负整数)
intvar = 37
print(intvar)

    # type() 查看一个值的数据类型
    res = type(intvar)
    print(res) #<class 'int'>
    # id() 查看一个变量所指向值的地址
    res = id(intvar)
    print(res)  #10915520

    # 二进制整型
    intvar = 0b1010101
    # 八进制整型
    intvar = 0o127
    # 十六进制整型
    intvar = 0xFF

    # 变量声明的第三种方式 特点
    a = b = 89
    res1 = id(a)
    res2 = id(b)
    print(res1)
    print(res2)
②Number类型之float 浮点型 （小数：1普通小数 2科学计数法表示的小数。例:a = 3e-5  #3e-05 ）
    (1)表示方式一
        floatvar = 3.14
    (2)表示方式二
        floatvar = 3.14e-2  # 小数点向左移动2位
        floatvar = 3.14e04  # 小数点向右移动4位
③Number类型之bool 布尔型 （True 真的 False 假的）
    boolvar = True
    boolvar = False    
④Number类型之complex 复数类型（实数+虚数 组成）
    ‘'' 如果有一个数，它的平方是-1，那么这个数就是j
        (科学家认为有，表达一个高精度的类型)
    '''
    (1) 表达方式一
        complexvar = 3 + 4j
        complexvar = 4j
    (2)表达方式二
        ''' var1 = complex(实数,虚数)
            通过complex强制转换成复数类型
        '''
        complexvar = complex(3, 5)

（2）String字符串型
特征：可获取，不可修改的有序容器类型数据。

# error
strvar="这是真的字符串"
strvar[-3] = "假"
print(strvar)

字符串有三种类型：通过单引号、双引号、三引号（可以支持跨行,不需要对单双引号进行转义）引起来的字符串。
转义字符：
语法: \ + 字符
(1)将无意义的字符变得有意义
(2)将有意义的字符变得无意义
例如：
\n 或者 \r\n : 代表换行
\t : 代表一个tab缩进(水平制表符)
\r : 把\r后面的字符提到行首
strvar = “处处\r蚊子咬”
print(strvar)
元字符串：r+字符串：作用在于让转义字符失效，原型化输出
strvar = r’夜来\n大狗熊’
print(strvar)
strvar = r”夜来\n大狗熊”
print(strvar)
strvar = r’’’夜来\n大狗熊’’’
print(strvar)
strvar = r”””夜来\n大狗\r熊\t”””
print(strvar)
（3）List列表类型
特征：可获取，可修改de有序容器类型数据。
定义空列表：
listvar = []
print(listvar)
列表值的获取：
listvar = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’]
res = listvar[1]
res = listvar[len(listvar) - 1]
列表的修改：
listvar = [‘a’, 14, 3,14, True, 4 + 3j]
listvar[1] = “15”
（4）Tuple元组类型
特征：可获取，不可修改的有序的容器类型数据
定义空元组：
tuplevar = ()
tuple类型的获取：
tuplevar = (‘a’, ‘c’, ‘b’, ‘s’, 15 - 9j, False)
res = tuplevar[-3]
tuple类型不支持修改

# error
tuplevar[0] = 1234
print(tuplevar)

(5)Set集合类型
特征：自动去重，无序的容器类型数据。
作用：集合类型是用来做交集、差集、并集、补集操作的。
注意点：
无法通过索引来获取其中的数据。
setvar = {True, “你好”, 34, 9.2, 3 + 4j}
print(setvar)
print(setvar[1]) # error
无法修改集合当中的值
setvar[0] = “999” # error
print(setvar)
单独定义一个{} 它代表的不是集合 而是字典
var = {} # 空字典
print(type(var)) #dict
var = set() # 空集合
print(type(var))
(6)Dict字典类型
特征：键值对存储的，无序容器类型数据。
dictvar = {‘top’: ‘程咬金’, ‘middle’: ‘貂蝉’, ‘bottm’: ‘鲁班七号’, ‘support’: ‘蔡文姬’, ‘jungle’: ‘韩信’}
字典的获取：通过键获取值
res = dictvar[‘jungle’]
print(res)
字典的修改
dictvar[‘middle’] = ‘小乔’
print(dictvar)

四、类型转换
–>自动类型转换
当2个不同类型的数据进行运算的时候,默认向更高精度转换数据类型精度从低到高:bool、int、float、complex。
–>强制类型转换
Number类型强制转换
通过int()、float()、complex()可以将整型、浮点型、布尔型以及纯数字字符串强转为对应的类型数据，而通过bool()则可以将Number类型数据和容器类型数据强转为bool类型数据。（扩展：布尔类型为假的时候，一共有10种情况：0, 0.0, False, 0j, ‘’, [], (), {}, set(), None）
容器类型强制转换
通过str()可以将Number类型和容器类型强制转为String型。
通过list()可以将字符串、列表、元组、集合、字典类型强制转换为List类型，把字典强转成列表,只要其中的键,忽略其中的值。
通过tuple()可以将容器类型数据强转为tuple类型数据，把字典强转成列表,只要其中的键,忽略其中的值。
通过set()可以将容器类型数据强制转换为集合类型数据，把字典强转成集合,只要其中的键,忽略其中的值。
dict()
使用 二级列表 或 二级元组 (二级集合语法上不错,但是无序,不建议使用)
‘’’强转成字典的条件：需要等长的二级容器’’’

方式一

var1 = [(“a”: 1), (“b”, 2)]
var2 = [[‘a’: 3], [‘b’: 4]]
var3 = [(‘a’: 5), [‘b’: 6]]

var4 = [{‘a’: 7}, {‘b’: 8}]

res = print(var4)

print(res, type(res))

方式二

var1 = ((‘a’, 1), (‘b’, 2))
var2 = ([‘a’, 3], [‘b’, 4])
var3 = ((‘a’, 5), [‘b’, 6])

var4 = [{‘a’,7},{‘b’,8}] 切记不要使用

res = dict(var4)

print(res)

方式三

var = {(‘a’, 1), (‘b’, 2)}
res = dict(var)
print(res)

五、以下数据类型存储规律仅对当前linux 64位的python3.x版本负责
–>Number 部分
1.对于整型而言，-5~正无穷范围内的相同值 id一致
2.对于浮点数而言，非负数范围内的相同值 id一致
3.布尔值而言,值相同情况下，id一致
4.复数的id标识都不相同(在 实数+虚数 这样的结构中)
–>容器类型部分
5.字符串而言，字符串值相同情况下，id一致
6.列表，元组，字典，集合无论什么情况 id标识都不同(但空元组的id标识一样)

六、Python运算符
(1)算数运算符: + - / // % **
(2)比较运算符: > < >= <= == !=
(3)赋值运算符: = += -= = /= //= %= **=
(4)成员运算符: in 和 not in (针对于容器型数据)
(5)身份运算符: is 和 is not (检测两个数据在内存当中是否是同一个值)
(6)逻辑运算符: and or not
True and print(1)
False and print(2) # 逻辑与短路
True or print(3) # 逻辑或短路
False or print(4)
(7)位运算符: & | ~ ^ << >>
按位非是对补码进行操作的，每一位按位取反，包括高位符号位(注意：原码和补码之间的互相转换，符号位不动)
运算规律：公式：-(x + 1)
例如：
~19
补码: 00000000 10011
按位非: 11111111 01100
给补码求原码:
取反:1111111 10011
加1 :1111111 10100 (原码)
最终: -20
~(-19)
原码：11111111 10011
给原码求补码：
取反：11111111 01100
加一：11111111 01101
按位非运算：
00000000 10010
最终：18
运算符的优先级：
一元运算符优先级 大于 二元运算符
一元运算符（~按位非 -负号）
例：~19只对一个数进行操作的运算符叫做一元运算符
二元运算符
例：1 + 2 对两个数 进行操作的运算符叫做二元运算符
运算符优先级最低的是 赋值运算符当中的=
运算符整体的优先顺序如下：
算数运算符 > 位运算符 > 比较运算符 > 赋值运算符 > 身份运算符 > 成员运算符 > 逻辑运算符

七、流程控制
大致分为三种控制结构：顺序结构、分支结构、循环结构。
分支结构分为：单项分支、双项分支、多项分支、巢状分支，通过if elif else关键字来构建。
循环结构分为while / for… in…，通过循环结构可以减少代码的冗余，提高执行效率。for…in…循环多用于遍历容器类型数据，而while则不能遍历无序的容器类型数据。在遍历字典时，默认遍历字典的键。遍历等长的二级列表：
listvar = [[‘a’, ‘b’, ‘c’], [‘d’, ‘e’, ‘f’], [‘g’, ‘h’, ‘j’]]
for i, j, k in listvar:
print(i, j, k)
字符串的拼接：
–>正常拼接：通过“+”来拼接。
a = ‘1’
b = ‘2’
print(a + b)
–>跨行拼接：通过\来衔接不同的多行。
strvar = “123456”\
“7890”
–>重复拼接：通过字符 次数。
strvar = ‘love’ 10

pass用来占位 / break终止当前循环，只能用在循环当中 / continue跳过当前循环，后面的代码不执行，直接从下一次循环开始

八、函数
关于函数
(1)函数的含义:功能 (包裹一部分代码 实现某一个功能 达成某一个目的)
(2)函数特点:可以反复调用,提高代码的复用性,提高开发效率,便于维护管理
(3)函数基本格式
def func():
pass
(4)驼峰命名法：（便于程序员更为方便的阅读代码）
大驼峰命名法：MyCar（用在类的命名中）；
小驼峰命名法：myCar（一般用在函数命名中）；
普通情况下，一般用_来分割不同的词。

# 99乘法表的定义
def multiplication99_table():
    for i in range(1, 10):;
        for j in range(1, i + 1):
            print("%d*%d=%2d " % (i, j, i*j), end="")
        print()
# 99乘法表的调用
multiplication99_table()

关于函数参数
(1)函数参数概念及分类
函数参数:调用时需要传递的数据.
函数参数大类分为形参和实参:
形参: 在函数定义时，括号里面的参数，叫形参（形式参数）
实参: 在函数调用时，括号里面的参数，叫实参（实际参数）
形参与实参的关系:函数调用时,形参和实参个数需要一一对应
形参种类:普通参数,默认参数,普通收集参数,命名关键字参数,关键字收集参数
实参种类:普通实参,关键字实参
默认形参和关键字实参区别：默认形参和关键字实参写法上一样，只不过默认形参在函数的定义处，关键字实参在函数的调用处。
(2)收集参数:
普通收集参数:在形参当中，号后面的参数是收集参数，用于专门收集多余的普通参数,形成一个新的元组。语法:参数前面加 例:*args。

# 例子：计算任意个数的累加和
def my_sum(*args):
    total = 0
    for i in args:
        total += i
    print(total)
my_sum(1, 2, 3, 77, 11)
关键字收集参数:用于专门收集多余关键字实参的是关键字收集参数,形成一个新的字典。语法:参数前面加**    例:**kwargs。
# 例子：任意参数的拼接
def link_str(**kwargs):
    print(kwargs)#{'monitor':'zhangbojin','zhangsan':'zhangsan','school_beauty':'wangitechui'}
    strvar1 = ''
    strvar2 = ''
    keydict = {'monitor':'班长','school_beauty':'校花'}
    for key,val in kwargs.items():
        if key in keydict:
            strvar1 += keydict[key] + val + '\n'
        else: 
            strvar2 += val
    print(strvar1+"今天结婚,喜结良缘"+",到场的吃瓜群众是"+strvar2)
link_str(monitor=" 张铂金 ",school_beauty=" 王铁锤 ",zhangsan = '张三' )

(3)命名关键字参数:定义时放在号后面的参数,调用时强制必须指定关键字实参才能调。
在函数定义时，写在后面的参数2是命名关键字参数（假定参数3是关键字收集参数）
语法:(*,x) x是命名关键字参数。
作用：在函数调用的时候，必须使用关键字实参进行调用**保证参数3不是关键字收集参数时，那么此刻参数2，参数3都是命名关键字参数

(4)关于和**的 实参 调用:在调用时,容器类型数据前面加 或者
在函数的调用处：例：func2(*listvar, dictvar)

• 用在修改容器类型的数据，把容器里面的数据，一个一个拿出来，当成参数传递给函数
  ** 用在修饰字典类型的数据，意味着把字典中的{键: 值} =>变成键=值,一个个当成参数赋值给函数调用

  小案例

  def func(a,b,*args,c,d):

  print(a,b)
  print(args)
  print(c)
  print(d)
  

  func(1,2,3,4,5,c=6,d=999)

  *号用法

  print(“======”)
  listvar = [1, 2, 3]
  func1(*listvar)

  func1(*listvar) 等价于 func1(1, 2, 3)

  **号用法

  dictvar = {‘d’: 4}
  func2(1, 2, 3, **dictvar)

  func2(1,2,3,**dictvar) 等价于 func2(1,2,3,d=4)

  函数的调用处

  func2(listvar,**dictvar)
  (5)形参声明的位置顺序:
  普通参数 -> 默认参数 -> 收集参数 -> 命名关键字参数 -> 关键字收集参数
  (6)对于任意函数，都可以通过 def func(args, **kw) 来获取所有参数

  参数练习：

  def f1(a, b, c=0, args, **kwargs):
  print(‘a =’, a, ‘b =’, b, ‘c =’, c, ‘args =’, args, ‘kw =’, kw)
  def f2(a, b, c=0, , d, *kw):
  print(‘a =’, a, ‘b =’, b, ‘c =’, c, ‘d =’, d, ‘kw =’, kw)

  以上两个函数 打印结果

  #(一)
  f1(1, 2) #a = 1 b = 2 c = 0 args = () kw = {}
  f1(1, 2, c=3) #a = 1 b = 2 c = 3 args = () kw = {}
  f1(1, 2, 3, ‘a’, ‘b’) #a = 1 b = 2 c = 3 args = (‘a’, ‘b’) kw = {}
  f1(1, 2, 3, ‘a’, ‘b’, x=99) #a = 1 b = 2 c = 3 args = (‘a’, ‘b’) kw = {‘x’: 99}
  f2(1, 2, d=99, ext=None) #a = 1 b = 2 c = 0 d = 99 kw = {‘ext’: None}
  #(二)
  args = (1, 2, 3, 4)
  kw = {‘d’: 99, ‘x’: ‘#’}
  f1(*args, **kw) #a = 1 b = 2 c = 3 args = (4,) kw = {‘d’: 99, ‘x’: ‘#’}

  f1(1,2,3,4,d=99,x=’#’)

  #(三)
  myargs = (1, 2, 3)
  mykw = {‘d’: 88, ‘x’: ‘#’}
  f2(*myargs, **mykw) #a = 1 b = 2 c = 3 args = (4,) kw = {‘d’: 99, ‘x’: ‘#’}

  f2(1,2,3,d=88,x=’#’)

  #(四)
  def f1(a, b, c=0, *args,d,**kw):
  print(‘a =’, a, ‘b =’, b, ‘c =’, c, ‘args =’, args, ‘kw =’, kw)
  print(d)
  f1(1,2,3, ‘a’, ‘b’,d=67, x=99,y=77) #a = 1 b = 2 c = 3 args = (‘a’, ‘b’) kw = {‘x’: 99, ‘y’: 77}

return返回值
为这个函数返回一个结果 (return返回值可有可无 按照需求选择)注意:执行return语句之后,函数执行结束

doc：doc或者help查看文档

全局变量、局部变量及其关键字的使用
– global 关键字:声明全局变量,作用在于修改全局变量
– nonlocal 关键字:声明函数内部的局部变量,作用在于修改局部变量(当前函数上一层的局部变量)

内部函数
(1)内部函数可以直接在函数外部调用么
(2)调用外部函数后,内部函数可以在函数外部调用吗
(3)内部函数可以在函数内部调用吗
(4)内部函数在函数内部调用时,是否有先后顺序

闭包
闭包的定义:
内函数使用外函数的局部变量，并且外函数将内函数返回出来的方法叫闭包,返回的内函数叫闭包函数。
闭包的特点:
外函数的临时变量会在将来的内部函数中用到,自己调用结束后会把外函数的临时变量与内函数绑定,不释放将来调用内函数的时候仍可使用外函数变量。
闭包的意义:
闭包可以优先使用外函数中的变量,并对闭包中的值起到了封装保护的作用.外部无法访问。

递归函数
递归的定义：自己调用自己就是递归函数。
递归的注意事项：
函数调用的过程就是开辟栈帧和释放栈帧的过程，调用结束时开辟栈帧空间，结束时释放（话外之意是不结束这层栈帧不释放）。
递归每次调用都会开辟一个栈帧，如果递归的层数过多，不建议使用，容易内存溢出。
每次开辟的栈帧空间，代码必须全部执行完毕之后才释放空间，在回到上一个栈帧执行没结束的代码。
如果使用递归，需要给予一个跳出的条件，不能无限递归。

匿名函数
实际上就是通过lambda表达式来书写的。一般只用来实现一些简单的函数功能，写法非常方便。

迭代器：
定义：能被next()函数调用并且不断返回下一个值的对象称为迭代器（Iterator 迭代器对象）。
特征：迭代器会生成惰性序列，它通过计算把值依次地返回，一边循环一边计算而不是一次性得到所有数据。
优点：需要数据的时候，一次取一个，可以大大节省内存空间，而不是一股脑地把所有数据放进内存。‘
惰性序列：没有一次性的把所有数据都放在序列中，而是遍历一个放一个，这样的序列叫做惰性序列。
Iterable可迭代性 Iterator迭代器
range是可迭代对象
range和迭代器能够产生惰性序列