一、数据类型

数据类型：整数、浮点数、字符串、布尔值
​
整数：十六进制：ox前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，很大的数可以用_分隔，10_000_000_000和10000000000是完全一样的，十六进制也可以写成0xa1b2_c3d4
​
浮点数：1.23x10^9和12.3x10^8是完全相等的，对于很大或很小的数，可以用科学计数法表示，把10用e代替，1.23x10^9就是1.23e9或12.3e8，0.000012可以写成1.2e-5，浮点数运算会有四舍五入的误差
​
字符串：用单引号'或双引号"括起来
​
布尔值：true false

二、字符串和编码

编码转换

UTF-8包含Unicode
对于单个字符的编码，Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换成对应的字符
ord('A') ===> 65
ord('中') ===> 20013
chr(66) ===> 'B'
chr(25991) ===> '文'
​
len()：字符串长度
replace(): 替换字符串

三、格式化输出

格式化输出，使用%：
    'Hello, %s' % 'world' ===> 'Hello world'
    'Hi, %s, you have $%d.' % ('Michael', 1000000) ==> 'Hi Michael, you have $1000000'
    
常见的占位符有：
    %d 整数
    %f 浮点数
    %s 字符串
    %x 十六进制整数
​
format()：使用传入的参数一次替换字符串内的占位符{0}、{1}...
'Hello, {0}, 成绩提升了 {1:.f}%' .format('小明', 17.125) ==> 'Hello，小明，成绩提升了17.1%'
​
f-string:使用以f开头的字符串，称之为f-string，如果包含{xxx}，就会替换掉相应的变量
r = 2.5
s = 3.14 * r ** 2
print(f'The area of a circle with radius {r} is {s:.2f}')
===> The area of a circle with radius 2.5 is 19.62

四、list集合

定义： list = [] , list = [1,2,3], list = ['Michael','Bob','Tracy']
元素个数：len()
获得索引位置元素：list[index]
获取最后一个元素：list[-1]
追加到末尾：list.append('元素')
插入到指定位置：list.insert(index,'元素')
删除末尾元素：list.pop()
删除指定位置元素：list.pop(i)
替换指定位置元素：list[index] = '元素'
排序：list.sort()
​
二维数组list = ['python','java',['asp','php'],'scheme']，要拿到'php'可以写成list[2][1]

五、tuple元组

tuple初始化：tuple = ('Michael','Bob','Tracy'), tuple = ()
tuple一旦初始化就不能更改，只有一个元素的时候必须加,来消除歧义，如tuple = (1,)
可以用index索引获取元素，没有append()，insert()等修改元素的方法，能用tuple的地方用tuple代替list
tuple不可变，但如果tuple里面的元素是list，可以改变list里面的数据，因为list的地址没变，只是list元素变了

六、条件判断

if elif else 
input()获取键盘输入

七、条件匹配

match ... case...
age = 15
match age:
    case x if x < 10:
        print(f'< 10 years old: {x}')
    case 10:
        print('10 years old.')
    case 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18:
        print('11~18 years old.')
    case 19:
        print('19 years old.')
    case _:
        print('not sure.')
        
注意: match是python3.10之后引入的特性

八、循环

for循环

for x in ...循环
案例：
names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)
    
sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    sum = sum + x
print(sum)
​
range()是python提供的一个函数，比如range(5)是从0到4的整数，range(101)是从0到100的整数

while 循环

while 循环，里面可以设置break，continue等语句
sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)
​
加入break语句
n = 1
while n <= 100:
    if n > 10: # 当n = 11时，条件满足，执行break语句
        break # break语句会结束当前循环
    print(n)
    n = n + 1
print('END')
​
加入continue语句
n = 0
while n < 10:
    n = n + 1
    if n % 2 == 0: # 如果n是偶数，执行continue语句
        continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
    print(n)

dict

dict全程dictionary，在其他语言中也称为map，使用key-value形式存储
dict = {'Michael':95,'Bob':75,'Tracy':85}
d['Michael'] ==> 95
​
为避免获取值失败，可以先判断key存不存在, key in dict ==> True/False
可以通过get()方法获取，如果key不存在返回None，或者自己指定的value
dict.get('Thomas') ==> None
dict.get('Thomas',-1) ==> -1
​
删除key：dict.pop(key)
​
dict和list相比：
    1.查找和插入的速度极快，不会随着key的增加而变慢
    2.需要占用大量的内存
注意：dict的key必须是不可变对象

set

set与dict类似，但是只存储key，而且不允许重复
创建一个set，需要提供list作为输入集合
s = set([1,2,3]) s ==> {1,2,3}
​
增加元素: add(key)
删除元素: remove(key)
​
set允许做数学意义上的交集、并集等操作
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}

九、函数

常用函数

绝对值：abs(数字), 例:abs(-10),如参数不对会报错，数量不对、参数类型不对
获取最大值：max(x...y), 例：max(1,2,4,6)
检查数据类型：isinstance(数字，(数据类型..)),例： isinstance(x,(int,float))，查看是否是整数或浮点数
​
数据类型转换
转换成整数：int(元素),例：int('123') ==> 123, int(12.34) ==> 12
转换成浮点数： float(元素)，例：float('12.34') ==> 12.34
转换成字符串： str(元素),例: str(1.23) ==> '1.23'
转换成布尔值： bool(元素)，例: bool(1) ==> True
​
转换城十六进制数： hex()

定义函数

def 函数名(参数):
    函数处理
        返回
​
例：获得绝对值
def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x
        
空函数:
def nop():
    pass
​
python函数允许返回多个值（表象），其本质是返回的tuple
​
总结：
1.定义函数时，需要确定函数名和参数个数
2.如果有必要，先对参数的数据类型做检查
3.函数体内部可以用return随时返回函数结果
4.函数执行完毕也没有return语句时，自动return None
5.函数可以同时返回多个值，但本质上是个tuple

函数参数

默认参数值，在不填入值的时候也不会报错
def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s
power(5) ==> 25 , power(5,3) ==> 125
​
注意：
    1.必选参数在前，默认参数在后
    2.变化大的参数在前，变化小的参数放在后
    
可变参数:可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple
def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
​
python允许你在list或tuple前加一个*号，把list或tuple的元素变成可变参数传进去：
>>> nums = [1, 2, 3]
>>> calc(*nums)
14
​
关键字函数：关键字参数允许你传入0个或任意个参数名的参数，这些关键字参数在函数内部自动组装为一个dict，用**kw表示。请看示例：
def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)
    
    
如果要弦值关键字参数的名字，可以命名关键字参数，如：
def person(name, age, *, city, job)：
    print(name, age, city, job)
    
和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数
调用方式如下：
person('Jack', 24, city='BeiJing', job='Engineer')
==> Jack 24 Beijing Engineer
​
参数组合
在python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数组合使用。但是参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数
比如一下定义的函数，包含5种参数：
​
def f1(a, b, c=0, *args, **kw):
    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)

递归函数

调用函数自身的函数，就是递归函数
阶乘函数n! = 1 x 2 x 3 x ... x n
def fact(n):
    if n == 1:
        return 1
    return n * fact(n - 1)