- 在Python中，直接给一个合法的名字赋值，这个变量就生成了。
# 语法:变量名 = 数据
a = 100
b = 100
c = 100
- 等号=是赋值的意思，左边是名字右边是值不可以写反。
a = 100
- 使用print()函数把括号里的内容显示到屏幕上。
print("这是一个字符串") # 这是一个字符串
print(100) # 100
- print()函数自带\n换行符，如果要实现不换行输出只需要在括号里面加上end=“”即可。
# 语法:print(参数,end="")
print("你好星期五", end=" ")
print("你好星期五")
# 你好星期五 你好星期五
print("你好", end=",")
print("星期五")
# 你好,星期五
- print()函数自带\n换行符，使用一个空的print()函数就相当于执行了\n换行符。
print("你好星期五")
print()
print("再见星期五")
# 你好星期五
# 再见星期五
- 变量名可以包含字母、数字、下划线、但不能以数字开头。
a1_5 = 100
print(a1_5) # 100
_1a5 = 100
print(_1a5) # 100
1a5_ = 100
print(1a5_) # 报错
- 小驼峰命名法:除了第一个单词以外，其它单词的首字母都是大写。
aa_Bb = 100
print(aa_Bb) # 100
Aa_Bb = 100
print(Aa_Bb) # 100
- 字母可以大写也可以小写，但大小写是完全不同的两个名字。
a = 100
A = 200
print(a) # 100
print(A) # 200
# 语法:type(任意参数)
a1 = 100
print(type(a1)) # <class 'int'>
a2 = 100.1
print(type(a2)) # <class 'float'>
print(type("星期五")) # <class 'str'>
a = 100
print(type(a)) # <class 'int'>
b = "100"
print(type(b)) # <class 'str'>
- 常量就是在程序运行过程中不可以改变的量（基本用不到，知道有这么个东西就行）。
- Python默认把全部大写的变量名来表示常量（基本用不到，知道有这么个东西就行）。
NAME = 100
print(NAME) # 100
- 在Python中可以随时修改变量的值，而变量中保存的值是最后一次赋的值。
a = 100
a = 200
a = 300
print(a) # 300
- Python可以将多个不同类型的数据指向同一个变量。
a1 = 100
print(a1) # 100
a1 = 100.11
print(a1) # 100.11
a1 = "星期五"
print(a1) # 星期五
- 数据一旦失去了变量的引用就会被Python的回收机制释放掉。
- 在Python中可以用中文名作为变量名（知道就行千万别这么写）。
星 = 100
print(星) # 100
星期五 = 100
print(星期五) # 100
print(星+星期五) # 200
a = 100
print(a) # 100
print(b) # 报错
b = 100
print(b) # 100
- 变量名不能包含空格，但能使用下划线_来分隔其中的单词。
# 在英语中单词之间是要写空格的。
start_time = 100
print(start_time) # 100
ni_hao = 100
print(ni_hao) # 100
a1 = a2 = 100
print(100+100) # 200
print(a1+a2) # 200
- 在Python中用两个连续的等号表示等于号，用单独的一个等号表示赋值。
a = 100
b = 100
print(a == b) # True
# del关键字后面会学到，目前了解一下就行
a = 100
print(a) # 100
del a # 删除变量a
print(a) # 报错
a = b = c = 100
print(a) # 100
print(b) # 100
print(c) # 100
a, b, c = 10, 20, 30
print(a) # 10
print(b) # 20
print(c) # 30
a, b = 10, 20
a, b = b, a # 将b的值赋给a，将a的值赋给b
print(a, b) # 20 10
- 变量包含四个部分:变量名、变量值、变量类型、变量内存地址。
# 使用id()函数查看变量的内存地址(id()函数后面会学到，目前了解一下就行)
# 运行一次程序内存地址也会跟着发生变化
a = 100
# 变量名:a
# 变量值:100
# 变量类型:整形
print(type(a)) # <class 'int'>
# 变量内存地址
print(id(a)) # 1957264166224
- 使用input()函数接收用户输入并将其赋给一个变量。
a1 = input("请输入字符串:")
print(type(a1)) # <class 'str'>
a2 = input()
print(type(a2)) # <class 'str'>
a3 = input(100)
print(type(a3)) # <class 'str'>
# 默认是一个str类型
a1 = input("请输入一个数字:") # 5
print(a1, type(a1)) # 5 <class 'str'>
# 把str类型转换成int类型
a2 = int(input("请输入数字:")) # 5
print(a2, type(a2)) # 5 <class 'int'>
# 把str类型转换成float类型
a3 = float(input("请输入一个数字:")) # 5.3
print(a3, type(a3)) # 5.3 <class 'float'>
- 使用f字符串把变量的值插入到字符串中，需要在字符串前面加上一个英文字母f，最后把要插入的变量放在大括号内。
a1 = 5
a2 = 5
a3 = a1 + a2
print(f"{a1}+{a2}={a3}") # 5+5=10
- 在使用f字符串时，只需要在变量名后面加上一个等号=，就可以把变量名和变量值一起打印出来（知道就行，基本用不到）。
a1 = "星期五"
a2 = 20
print(f"姓名:{a1=}\n年龄:{a2=}")
# 姓名:a1='星期五'
# 年龄:a2=20
print(f"姓名:{a1}\n年龄:{a2}")
# 姓名:星期五
# 年龄:20
- f字符串是Python3.6引入的，如果你使用的是Python3.5或更早的版本，就需要使用format()方法。
- 使用format()方法，把变量的值插入到字符串中,需要在字符串后面加上一个.format()，最后把要插入的变量放在小括号内（看得懂就背，看不懂学到后面再回来背）。
# 语法:"{}{}{}……".format(变量，变量，变量……)
a1 = "你好"
a2 = "星期五"
print("{}{}".format(a1, a2)) # 你好星期五
print("{}{}".format("你好", "星期五")) # 你好星期五
- 使用索引来确保参数被放在正确的占位符中（看得懂就背，看不懂学到后面再回来背）。
a1 = "星期六"
a2 = "星期天"
print("你好{0},你好{1}".format(a1, a2)) # 你好星期六,你好星期天
print("你好{1},你好{0}".format(a2, a1)) # 你好星期六,你好星期天
- 使用关键字来确保参数被放在正确的占位符中（看得懂就背，看不懂学到后面再回来背）。
a1 = "星期六"
a2 = "星期天"
print("你好{a2},你好{a1}".format(a1="星期天", a2="星期六")) # 你好星期六,你好星期天
print("你好{a1},你好{a2}".format(a1, a2)) # 报错
- 使用format()方法可以混合搭配，索引和默认格式不能混合使用，关键字参数必须写在最后面（看得懂就背，看不懂学到后面再回来背）。
b1 = "你好"
b2 = "星期天"
print("{}{},{a2}{a1}".format(b1, b2, a2="再见", a1="星期六")) # 你好星期天,再见星期六
print("{0}{1},{a2}{a1}".format("你好", "星期五", a2="再见", a1="星期六")) # 你好星期五,再见星期六
- 使用format_map()方法，将字典中的键作为要插入的变量，将字典中的值作为要插入的值，大括号放的是键，键必须是字符串，小括号放的是字典（看得懂就背，看不懂学到后面再回来背）。
# 语法:"{键}{键}{键}……".format_map(字典)
x = {"yi": "星期一", "er": "星期二", "san": "星期三"}
a = "{yi}，{er}，{san}".format_map(x)
print(a) # 星期一，星期二，星期三
- Python允许在同一行使用多条语句，用分号隔开即可（知道就行千万别这么写）。
a = 100; b = 200; c = 300
print(a); print(b); print(c)
# print()函数自带换行符，所以输出了三行
# 100
# 200
# 300
print("你好星期五") # 单行注释
print("你好星期六")
"""
多行
注释
"""
'''
多行
注释
'''
- 书写很大的数时，可以使用下划线将其中的数字分组，这种表示法适用于整型和浮点型（不常用）。
a1 = 1_000_000_000
print(a1) # 1000000000
a2 = 100.000_000_000
print(a2) # 100.0
a1 = 100
a2 = 200
a3 = 300
print(a1, a2, a3) # 100 200 300
print("你好", "星期五", "再见", "星期五") # 你好 星期五 再见 星期五
- 在Python中，用引号括起来的都是字符串，其中的引号可以是单引号、双引号、三引号。
print('这是单引号') # 这是单引号
print("这是双引号") # 这是双引号
print("""这是三引号""") # 这是三引号
- 如果行数非常多，只需要使用三重引号字符串就可以轻松解决问题。
print("""你好星期五
再见星期五
你好星期六
再见星期六
""")
# 你好星期五
# 再见星期五
# 你好星期六
# 再见星期六
- 正斜杠/向左下角斜，它在键盘上的位置通常是在回车键的左下角。
- 反斜杠\向右下角斜，它在键盘上的位置通常是在回车键的上方。
# 表达式
x = 1 + 2 + \
3 + 4
print(x) # 10
- （）小括号、[]中括号、{}大括号，可以将一行语句分为多行显示，无需使用反斜杠（看得懂就背，看不懂学到后面再回来背）。
# 列表
a1 = [1, 2,
3, 4]
print(a1) # [1, 2, 3, 4]
# 元组
a2 = (1, 2,
3, 4)
print(a2) # (1, 2, 3, 4)
# 字典
a3 = {1: "星期一", 2: "星期二",
3: "星期三", 4: "星期四"}
print(a3) # {1: '星期一', 2: '星期二', 3: '星期三', 4: '星期四', 5: '星期五'}
# 集合
a4 = {1, 2,
3, 4}
print(a4) # {1, 2, 3, 4}
- 计算1.1 + 2.2时会出现小数位不正确的情况，计算其它个别数也会出现这种情况(不用深究，了解一下就行)。
print(0.1+0.2) # 0.30000000000000004
print(1.1+2.2) # 3.3000000000000003
print(2.1+3.2) # 5.300000000000001
- 整型int、浮点型float、布尔类型bool、字符串str、列表list、元组tuple、字典dict、集合set、复数类型complex。
- Python3的整型已经与长整型进行了无缝结合，它的长度不受限制，如果说非要有个限制，那只限于你电脑的性能，所以Python很容易进行大数计算。
print(99999999999999999999*9999999999999999999999999999) # 999999999999999999989999999900000000000000000001
a = 1.5
print(a) # 1.5
a = 3.14
print(a) # 3.14
- 使用int()函数将一个字符串或一个浮点数转换成一个整数。
# 语法:int(参数)
print(int("100")) # 100
print(int(100.1)) # 100
- 使用float()函数将一个字符串或一个整数转换成一个浮点数。
# 语法:float(参数)
print(float("100")) # 100.0
print(float(100)) # 100.0
# 语法:str(参数)
print(str(100)) # 100
print(str(100.1)) # 100.1
- 如果是浮点数转换为整数，那么Python会采取截断处理，就是把小数点后的数据直接砍掉，注意不是四舍五入。
a = 3.54
print(int(a)) # 3
- 这种字符串+字符串的语法在Python的世界里称为字符串的拼接。
a1 = "再见"
a2 = "星期五"
print(a1+a2) # 再见星期五
print("你好"+"星期五") # 你好星期五
a1 = 100
a2 = 100
print(100+100) # 200
print(a1+a2) # 200
- str类型 + int类型 = 报错（所以不能用字符串加整数）。
a1 = 100
a2 = "100"
print(a1+a2) # 报错
print(100+"100") # 报错
- 如果字符串中需要出现单引号或双引号有两种方法，第一种就是使用转义符号\对字符串中的引号进行转义，第二种就是利用Python既可以使用单引号也可以使用双引号这个特点，只要用上不同的引号Python就不会误解你的意思了。
print("这是一个\"字\"符串") # 这是一个"字"符串
print('这是一个"字"符串') # 这是一个"字"符串
- 如果字符串中有很多个反斜杠就使用原始字符串，原始字符串的使用非常简单，只需要在字符串前面加上一个英文字母r即可。
print(r"这是一个\\字符串\n") # 这是一个\\字符串\n
print(r'这是一个\\字符串\n') # 这是一个\\字符串\n
- 在使用字符串时需要注意的一点是无论是否原始字符串，都不能以反斜杠作为结尾，反斜杠放在字符串的末尾表示该字符串还没有结束换行继续的意思。
print("这是一个字符串\") # 报错
print(r"这是一个字符串\") # 报错
- 布尔类型只有两个值，True和False就是真与假。
- 布尔类型事实上是特殊的整型，True相当于整型值1，False相当于整型值0。
print(True+False) # 1 + 0 = 1
print(True+True) # 1 + 1 = 2
print(False + 1) # 0 + 1 = 1
print(1 + True) # 1 + 1 = 2
- 复数类型由实数部分和虚数部分组成（看得懂就背，看不懂学到后面再回来背）。
- 电脑中保存的数据默认以二进制形式进行存储，二进制由0和1组成。
- 每一个数据都对应着一个二进制，将二进制1000001存储在电脑中就相当于将字母A存储在电脑中。
- 8bit（位） = 1byte（字节）、1024byte = 1KB、1024KB = 1MB、1024MB = 1GB、1024GB = 1TB、1024TB = 1PB。
- 在电脑中两个二进制位有4种组合方式，八个二进制位有255种组合。
# 两个位置:00、11、01、10
- 一个字节在十进制中最大可以表示为255，在整数中最大可以表示为256。
# Python默认以十进制形式进行输出，所以八个位置最大可以表示为255
print(2*2*2*2*2*2*2*2-1) # 十进制:255
print(2*2*2*2*2*2*2*2) # 整数:256
- 8个位置表示一个字节，如果你想在电脑中表示更大的数，就必须用更多的字节。
# 使用bin()函数将其它进制转换成二进制。
print(bin(255)) # 八位二进制数:11111111
print(bin(256)) # 九位二进制数:100000000
- Python默认以十进制形式进行输出，不管你输入任意进制它都会自动转换成十进制。
print(0b1100100) # 100
print(0o144) # 100
print(100) # 100
print(0x64) # 100
print(0b1100100) # 100
- 八进制以0o开头:0、1、2、3、4、5、6、7(逢八进一)。
print(0o144) # 100
- 十进制是默认的进制:0、1、2、3、4、5、6、7、8、9(逢十进一)。
print(100) # 100
- 十六进制以0x开头:0、1、2、3、4、5、6、7、8、9、A、B、C、D、E、F(逢十六进一)（大小写都行）。
print(0x64) # 100
# 语法:bin(任意进制)
# 其它进制转二进制
print(bin(0b1100100)) # 二进制转二进制:0b1100100
print(bin(0o144)) # 八进制转二进制:0b1100100
print(bin(100)) # 十进制转二进制:0b1100100
print(bin(0x64)) # 十六进制转二进制:0b1100100
# 语法:oct(任意进制)
# 其它进制转八进制
print(oct(0b1100100)) # 二进制转八进制:0o144
print(oct(0o144)) # 八进制转八进制:0o144
print(oct(100)) # 十进制转八进制:0o144
print(oct(0x64)) # 十六进制转八进制:0o144
# 语法:int(任意进制)
# 其它进制转十进制
print(int(0b1100100)) # 二进制转十进制:100
print(int(0o144)) # 八进制转十进制进制:100
print(int(100)) # 十进制转十进制:100
print(int(0x64)) # 十六进制转十进制:100
# 语法:hex(任意进制)
# 其它进制转十六进制
print(hex(0b1100100)) # 二进制转十六进制:0x64
print(hex(0o144)) # 八进制转十六进制:0x64
print(hex(100)) # 十进制转十六进制:0x64
print(hex(0x64)) # 十六进制转十六进制:0x64
- 使用chr()函数将任意进制转换成对应的单个字符。
# 语法:chr(参数)
print(chr(0b110011000011111)) # 二进制转字符:星
print(chr(0o63037)) # 八进制转字符:星
print(chr(26143)) # 十进制转字符:星
print(chr(0x661f)) # 十六进制转字符:星
- 使用ord()函数将单个字符转换成对应的十进制编码。
# 语法:ord(单个字符)
# 字符转十进制
print(ord("五")) # 20116
print(ord("A")) # 65
print(ord("1")) # 49
# 字符转二进制
print(bin(ord("五"))) # 0b100111010010100
print(bin(ord("A"))) # 0b1000001
print(bin(ord("1"))) # 0b110001
# 字符转八进制
print(oct(ord("五"))) # 0o47224
print(oct(ord("A"))) # 0o101
print(oct(ord("1"))) # 0o61
# 字符转十六进制
print(hex(ord("五"))) # 0x4e94
print(hex(ord("A"))) # 0x41
print(hex(ord("1"))) # 0x31
- 常用的运算符:算术运算符、赋值运算符、比较运算符、位运算符、逻辑运算符、身份运算符、成员运算符。
- Python算术运算符:+加、-减、*乘、/除、%取余、**幂运算、//地板除法。
+、-、*、/、%、**、//
- Python赋值运算符:= 赋值运算符、+= 加等于、-= 减等于、*= 乘等于、/= 除等于、%= 取余等于、**= 幂运算等于、//= 地板除法等于。
=、+=、-=、*=、/=、%=、**=、//=
- Python比较运算符:< 小于、<= 小于等于、> 大于、>= 大于等于、== 等于、!= 不等于。
<、<=、>、>=、==、!=
- Python逻辑运算符:and逻辑与、or逻辑或、not逻辑非。
and、or、not
is、is not
in、not in
- Python的逻辑运算符可以将任意表达式连接在一起，并得到一个布尔类型值。
print(1 < 2 and 3 < 4) # True
print(1 < 2 or 3 < 4) # True
print(not 1 < 2) # False
- and逻辑运算符，只有当两边都为真时，结果才为真，否则为假。
print(True and True) # True
print(100 < 200 and 200 < 300) # True
print(True and False) # False
print(100 < 200 and 200 > 300) # False
print(False and False) # False
print(100 > 200 and 200 > 300) # False
- or逻辑运算符，只要任意一边为真，结果就为真，只有当两边同时为假时结果才为假。
print(True or True) # True
print(100 < 200 or 200 < 300) # True
print(True or False) # True
print(100 < 200 or 200 > 300) # True
print(False or False) # False
print(100 > 200 or 200 > 200) # False
- not逻辑运算符，是一个一元运算符，它会得到一个和值相反的布尔类型值。
print(not True) # False
print(not 100) # False
print(not False) # True
print(not 0) # True
print(not 1 < 2) # False
- 逻辑运算符的优先级:not > and > or。
print(True or False and True) # True
print(False or not False) # True
print(True or True and False) # True
- 3 < 4 < 5在其它编程语言中一般是不合法的，但在Python中是行得通的，它被解释为3<4 and 4<5。
print(3 < 4 < 5) # True
print(3 > 4 > 5) # False
print(3 > 4 < 5) # False
print(3 < 4 or 4 < 5) # True
print(3 > 4 or 4 > 5) # False
print(3 > 4 or 4 < 5) # True
- 3 < 4 < 5这种简写用的是and逻辑运算符，其它逻辑运算符不能用简写。
# 语法:id(参数)
# 内存地址并不是固定的，运行一次程序内存地址就会变化一次
a = 100
print(id(a)) # 1969978346832
print(id(100)) # 1969978346832
print(id("星期五")) # 1969983899088
- 使用is关键字判断两个变量是否引用同一个id（内存地址），是返回True，不是返回False。
a1 = 100
a2 = 100
print(a1 is a2) # True
print(100 is 101) # False 使用is判断两个值，虽然会输出但是会报错。
print(100 is 100) # True 使用is判断两个值，虽然会输出但是会报错。
- 使用is not关键字判断两个变量是否引用不同id（内存地址），是返回True，不是返回False。
a1 = 100
a2 = 100
print(a1 is not a2) # False
print(100 is not 101) # True 使用is not判断两个值，虽然会输出但是会报错。
print(100 is not 100) # False 使用is not判断两个值，虽然会输出但是会报错。
- 使用in关键字判断左边的值是否包含在右边的内容中，包含返回True，不包含返回False。
a1 = "你好星期五"
print("星期五" in a1) # True
a1 = [1, 2, 3, 4, 5, [1, 2]]
print(1 in a1) # True
print([1, 2] in a1) # True
- 使用not in关键字判断左边的值是否不包含在右边的内容中，不包含返回True，包含返回False。
a1 = "你好星期五"
print("星期五" not in a1) # False
a1 = [1, 2, 3, 4, 5, [1, 2]]
print(1 not in a1) # False
print([1, 2] not in a1) # False
- 很多编程语言的除法一般都是地板除法，地板除法的概念就是舍弃小数的意思，Python用真正的除法代替了地板除法。
print(5/2) # 2.5 真正的除法
print(5//2) # 2 地板除法
- 使用地板除法运算时，一正一负向下取整（看得懂就背，看不懂学到后面再回来背）。
print(9//-4) # -3
print(-9//4) # -3
- 使用取余运算符时，一正一负遵循公式:余数 = 被除数 - 除数 * 商（看得懂就背，看不懂学到后面再回来背）。
print(9 % -4) # -3
print(-9 % 4) # 3
- 新手目前只需要了解三个编码:ASCII编码、Unicode编码、UTF-8编码。
- Unicode编码几乎包含了全世界的字符（浪费空间、浪费资源）（万国码）。
- Python2中默认编码为ASCII，所以要在文件开头写一句编码声明:# encoding = utf-8，Python3中默认编码为UTF-8所以不用在文件开头写编码声明。
# 新手了解一下就行，Python3不用写编码声明
# encoding = utf-8
print("你好星期五") # 你好星期五
print("再见星期五") # 再见星期五
a = b = 10
if a < b:
pass
else:
pass
- None不能理解为0，因为0是有意义的，而None是一个特殊的空值（空值也就是没有值，看的懂就背，看不懂学到后面再回来背）。