运行效率较低
type(被查看类型的数据)：查看数据类型
整数（int）
Python可以处理任意大小的整数
0b表示，例如：0b110，0b11000x表示，例如：0x12ef，0xde2431af浮点数（float）
浮点数可以用正常写法：1.23，3.14，-9.01
也可以使用科学计数法表示：1.23e9（1.23*10^9）
注意：浮点数的运算可能会有误差
复数（complex）
以j结尾表示复数，如4+3j
布尔值（bool）
布尔值只有True，False两种值，可以使用and，or，not进行运算
True本质上是一个数字记作1，False记作0
描述文本的一种数据类型
字符串可以用’'或""括起来表示
如果字符串本身包含单引号，这时可以用双引号括起来表示，如果包含双引号，就可以用单引号括起来表示，如果字符串既包含单引号也包括双引号，那么需要使用\进行转义。
常用的转义字符还有：
\n表示换行
\t 表示一个制表符
\\表示 \ 字符本身
raw字符串
如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦，我们可以在字符串前面加个r，表示这是一个raw字符串，里面的字符就不需要转义了。
print(r"c:\newfile\test.py")
#c:\newfile\test.py
print("c:\newfile\test.py")
#c:
#ewfile est.py
raw'...'，不能表示多行字符串，也不能表示包含’和"的字符串（不能转义）
多行字符串
使用'''...'''表示多行字符串
print('''Line 1
Line 2
Line 3''')
也可以在多行字符串前面添加
r，把这个多行字符串也变成raw字符串
字符串切片
前闭后开区间
s = 'ABCDEFG'
s1 = s[0:2]
print(s1) # AB
s2 = s[2:4]
print(s2) # CD
以’'或""括起来的任意文本
字符串拼接
通过+可以将两个字符串拼接在一起
name = "world"
print("hello" + name) # helloworld
字符串格式化
%占位
% 表示：我要占位
s 表示：将变量变成字符串放入占位的地方
综合起来：我先占个位置，等一会有个变量过来，我把它变成字符串放到占位的位置
（%d：将内容转换成整数，放入占位位置；%f：将内容转换成浮点数，放入占位位置）
name = "David"
tel = 1234567
message = "姓名：%s，电话：%d" % (name, tel)
print(message) # 姓名：David，电话：1234567
print("%f" % tel) # 1234567.000000
精度控制
可以使用符号m.n来控制数据的宽度和精度
m控制宽度，要求是数字，设置的宽度小于数字自身，不生效
.n控制小数点精度，要求是数字，会进行小数的四舍五入
print("%5d" % 11) # [空格][空格][空格]11，用三个空格补齐宽度
print("%7.2f" % 11.345) # [空格][空格]11.35，小数部分限制两位四舍五入为.35，用两个空格补齐宽度
print("%.2f" % 11.345) # 11.35，不限制宽度，只设置小数点精度为2
f"内容{变量}"
name = "David"
sex = "male"
age = 20
print(f"我是{name}，我的性别是{sex}，我的年龄是{age}")
format
print('{} {}'.format("hello", "world")) # hello world
print('{0} {1}'.format("hello", "world")) # hello world
print('{1} {0}'.format("hello", "world")) # world hello
print("hello:{country}, hello:{city}".format(country="china", city="beijing")) # hello:china, hello:beijing
a = 3
b = 4
print('{} + {} = {}'.format(a, b, a+b)) # 3 + 4 = 7
有序的可变序列
有序的不可变序列
无序不重复集合
无序Key-Value集合
空值
空值用None表示
- 函数无返回值
- if判断：None等同于False
- 声明无内容变量
浮点数转换为整数会丢掉小数部分，字符串必须为纯数字才能转换为数字
标识符的命名规则
- 大小写敏感
- 标识符由大小写英文字母、数字、中文和下划线组成（不推荐使用中文）
- 标识符不能由数字开头
- 标识符不能与Python关键字重合（比如：and、or、not）
标识符命名规范
- 英文字母全小写
- 多个单词之间用下划线分隔
变量没有类型，字符串变量表示变量存储了字符串而不是表示变量就是字符串
变量名 = 数据
一个变量可以先后存储多种不同类型的数据
a = 1 # 这个时候a存储的是整数类型
print(a)
a = 'ABC' # 这个时候a存储的是字符串类型
print(a)
加减乘除
整数与浮点数运算的结果是浮点数
除法的运算结果是浮点数
# 加法
num1 = 10
num2 = 0.5
result = num1 + num2
print(result) # ==> 10.5
# 减法
result = num1 - num2
print(result) # ==> 9.5
# 乘法
result = num1 * num2
print(result) # ==> 5.0
# 除法
result = num1 / num2
print(result) # ==>20.0
取模
print(3 % 2) # ==> 1
print(33 % 10) # ==> 3
print(99 % 30) # ==> 9
地板除
与普通除法相比，会忽略结果的纯小数部分，使用//进行
都为整型则结果也为整型，只要有一个float，则返回float
print(10//4) # ==> 2
print(10//2.5) # ==> 4.0
print(10//3) # ==> 3
保留小数点位数
round()，第一个参数是需要保留小数点位数的数值，第二个参数是保留的位数print(round(3.344, 2)) # ==> 3.34 print(round(3.345, 2)) # ==> 3.35
指数
a**b：为a的b次方
print(5**2) # ==> 25
数据输出：print()
print("hello", end="")
数据输入：input()
与运算
两个布尔值都为True时，结果为True
True and True # ==> True
True and False # ==> False
False and True # ==> False
False and False # ==> False
或运算
只要有一个值为True，结果就为True
True or True # ==> True
True or False # ==> True
False or True # ==> True
False or False # ==> False
非运算
True变为False，False变为True
not True # ==> False
not False # ==> True
布尔类型也可以与其他类型做运算
Python把0、空字符串和None看成False，其他数值和非空字符串都看成True
print(True and 0 or 99) # ==> 99
要解释以上结果需要涉及到短路计算
- 在计算
a and b时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。- 在计算
a or b时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b
True and 0 or 99：首先计算True and 0，根据短路计算返回0，然后计算0 or 99，根据短路计算返回99
比较运算符
==、!=、>、<、>=、<=
if/else判断的一个子分支（表示这行代码属于哪个语句）:，表示接下来是分支代码块score = 59
if score < 60:
print('抱歉，考试不及格')
else:
print('恭喜你，考试及格')
elif 相当于 else if ， 可以简化逻辑
score = 59
if score < 60:
print('抱歉，考试不及格')
else:
if score >= 90:
print('恭喜你，拿到卓越的成绩')
else:
if score >= 80:
print('恭喜你，拿到优秀的成绩')
else:
print('恭喜你，考试及格')
score = 59
if score < 60:
print('抱歉，考试不及格')
elif score >= 90:
print('恭喜你，拿到卓越的成绩')
elif score >= 80:
print('恭喜你，拿到优秀的成绩')
else:
print('恭喜你，考试及格')
特别注意: 这一系列条件判断会从上到下依次判断，如果某个判断为 True，执行完对应的代码块，后面的条件判断就直接忽略，不再执行了。
输出0～99
i = 0
while i < 100:
print(f"i = {i}")
i += 1
for 临时变量 in 待处理数据集:
循环满足条件时执行的代码
将待处理数据集中的数据挨个取出，每一次循环就将当前数据赋予这个临时变量，在循环体中使用
str = "Hello"
for x in str:
print(x)
"""
H
e
l
l
o
"""
待处理数据集，严格来说称之为：序列类型
序列类型指：其内容可以一个个依次取出的一种类型，包括：
range语句
生成数字序列
在for循环外部可以访问临时变量，但在编程规范上是不允许这样做的
for x in range(10): print(f"{x} ",end="") print(x) # 0 1 2 3 4 5 6 7 8 9 9如果想访问for循环内部变量，则应该在for循环外部预先定义
x = 0 for x in range(10): print(f"{x} ",end="") print(x) # 0 1 2 3 4 5 6 7 8 9 9for循环相当于对x进行了10次内容覆盖
定义
def 函数名(传入参数):
函数体
return 返回值
传入参数
功能：在函数进行计算的时候，接受外部（调用时）提供的数据
def add(x, y):
result = x + y
print(f"{x} + {y}的计算结果是：{result}")
add(1,2)
返回值
def add(a, b):
result = a + b
return result
r = add(1, 2)
print(r)
说明文档
在函数体之前通过多行注释的形式，对函数进行说明解释
pycharm在函数名之后输入"""回车会自动补全注释
def add(x, y):
"""
:param x:
:param y:
:return:
"""
result = x + y
return result
def add(x, y):
"""
add函数可以接收2个参数，进行2数相加的功能（整体说明）
:param x:形参x表示相加的其中一个数字（参数说明）
:param y:形参y表示相加的另一个数字
:return:返回值是2数相加的结果（返回值说明）
"""
result = x + y
return result
鼠标悬停可以查看文档
变量作用域
局部变量：在函数体内定义的变量，只能在函数体内使用
全局变量：在函数体外定义的变量，函数体内外都能使用
以下示例中，test函数内部相当于重新定义了一个num变量赋值为500，此时函数外部的num变量并没有被修改
num = 100
def test():
num = 500
print(num)
test()
print(num)
# 500
# 100
要想在函数内部修改全局变量需要使用global关键字
global：在函数内部声明变量为全局变量
此时test()中的num和函数外的num就是同一个变量了
num = 100
def test():
global num
num = 500
print(num)
test()
print(num)
# 500
# 500
一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素，每一个元素可以是任意类型的数据，如字符串、数字、布尔等。
可以容纳多个元素（上限为2**63-1）
可以容纳不同类型的元素
数据有序存储（有下标序号）
允许重复数据存在
可以修改、增加或删除元素
基本语法
以[]作为标识，列表内每一个元素之间用逗号隔开
元素可以为不同的数据类型，支持嵌套
# 定义列表
list1 = [1, 2, True, "hello"]
# 定义空列表
list2 = []
list3 = list()
下标索引
从前向后：从0开始，依次递增
从后向前：从-1开始，依次递减
list1 = [1, 2, True, "hello", [1, 2, 3]]
print(list1[0]) # 1
print(list1[-1][1]) # 2
元组与列表类似，最大的不同点在于：元组一旦定义完成，就不可修改
基本语法
使用小括号定义，元素之间使用逗号分隔，数据可以是不同的数据类型
# 定义元组
tuple1 = (1, 2, "hello", [1, 2], (3, 4))
# 定义空元组
tuple2 = ()
tuple3 = tuple()
注意：如果元组只有一个数据，这个数据后面要添加逗号，否则不是元组类型
tuple1 = (1)
print(type(tuple1)) # int
tuple2 = (1,)
print(type(tuple2)) # tuple
元组的操作方法和列表相同，但是不能增加/删除/修改元素
注意：元组的内容不能修改，但是可以修改元组中嵌套的list的内容
tuple1 = (1, [1, 2, 3])
tuple1[1][1] = 1
print(tuple1) # (1, [1, 1, 3])
一个字符串可以存放任意数量的字符
下标索引
从前向后，下标从0开始
从后向前，下标从-1开始
注意：同元组一样，字符串是一个无法修改的容器，如果想要修改/删除/追加字符只能通过建一个新的字符串。
序列：内容连续、有序，可使用下标索引的一类数据容器（列表、元组、字符串）
切片：从一个序列中，取出一个子序列
语法：序列[起始下标:结束下标:步长]
此操作不会影响序列本身，而是会得到一个新的序列
[::-1]：表示将序列反转
不支持重复元素且内容无序
基本语法
使用{}定义
空集合使用set()定义，不能使用{}，{}是字典
# 定义集合变量
set1 = {1, 2, "hello"}
# 定义空集合
set2 = set()
不能使用下标取元素，但是集合和列表一样可以修改
集合不支持下标索引，不能用while循环遍历，可以用for循环
set1 = {1, 2, "hello"}
for i in set1:
print(i)
基本语法
使用{}定义，不过存储的元素是一个个的：键值对
# 定义字典变量
dict1 = {"zhangsan": 30, "lisi": 40, "wangwu": 50}
# 定义空字典
dict2 = {}
dict3 = dict()
字典不允许key重复，重复添加会把前面的覆盖掉
# 定义字典变量
dict1 = {"zhangsan": 30, "zhangsan": 40, "wangwu": 50}
print(dict1["zhangsan"]) # 40
不可以通过下标索引，可以通过key值来取得对应的value
key和value可以是任意数据类型（key不可为字典）
遍历字典：可以首先通过keys获取字典中的全部key进行遍历，也可以for循环遍历每次取得的就是字典的key
通用操作
遍历
多个返回值之间用逗号隔开
支持不同类型的数据return
def test_return():
return 1, 2
t = test_return()
print(type(t)) # <class 'tuple'>
print(t) # (1, 2)
x, y = test_return()
print(x, y) # 1 2
位置参数
调用函数时根据函数定义的参数位置来传递参数
def user_info(name, age, gender):
print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
user_info('TOM', 20, '男')
关键字参数
函数调用时通过“键=值”的形式传递参数
def user_info(name, age, gender):
print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
user_info(gender='女', name='Alice', age=25)
可以不固定顺序
可以和位置参数混用，位置参数必须在前，且匹配参数顺序
def user_info(name, age, gender):
print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
user_info('Alice', gender='女', age=25)