数据类型
通过 print(type(x)) 可以输出 x 的数据类型,type() 函数可以获取数据类型
整数
a = 10
print(type(a))
浮点数
a = 0.5
print(type(a))
字符串
a = 'hello'
print(type(a))
获取字符串长度
a = 'hello'
print(len(a))
字符串拼接
a = 'hello'
b = 'world'
print(a + b)
布尔
布尔类型只有两种值 True 真 和 False 假
a = True
print(type(a))
b = False
print(type(b))
注释
单行注释
# 注释
文档注释
'''
注释
注释
'''
"""
注释
注释
"""
输入输出
输入
input()
使用 input() 函数进行输入操作,当程序运行到 input() 函数时
会将括号内的内容先打印出来,然后等待用户进行输入,当用户敲下回车时,输入结束
输出
print()
使用输入输出
# 定义一个整型变量 num
num = 0
# 输入一个整型数据 将其赋值给 num 变量
num = input('请输入一个整数: ')
# 输出 num 变量
print(f'你输入的整数是 {num}')
使用 f 作为前缀的字符串,称为 f-string
这种字符串可以在字符串里使用 { } 将变量或表达式内嵌到字符串中
运算符
算术运算符
加法 +
减法 -
乘法 *
除法 /
取模 %
乘方 **
除法取整 //
关系运算符
< 小于
<= 小于等于
> 大于
>= 大于等于
== 等于
!= 不等于
带有这种关系运算符的表达式结果一般为布尔类型 True or False
a = 10
b = 20
print(a < b)
print(a <= b)
print(a > b)
print(a >= b)
print(a == b)
print(a != b)
除了判断数字也可以判断字符串,字符串的大小由 abc~xyz 的字典序决定,越后越大
a = 'hello'
b = 'world'
print(a < b)
print(a <= b)
print(a > b)
print(a >= b)
print(a == b)
print(a != b)
逻辑运算符
and 并且
or 或者
not 取反
a = 10
b = 20
c = 30
print(a < b and b < c)
print(a < b and b > c)
print(a > b or b > c)
print(a < b or b > c)
print(not a < b)
print(not a > b)
赋值运算符
# 直接赋值
a = 10
# 从右往左 链式赋值
a = b = 10
# 多元赋值
a, b = 10, 20
a += 1 ( a = a + 1 )
a -= 1 ( a = a - a )
a *= 1 ( a = a * 1 )
a /= 1 ( a = a / 1 )
a %= 1 ( a = a % 1 )
身份运算符
is 是
is not 不是
成员运算符
in 在
not in 不在
位运算符
& 按位与
| 按位或
^ 按位异或
<< 左移
>> 右移
条件语句
if 条件 :
操作
操作
下一条语句
if 条件 :
操作
操作
else:
操作
操作
if 条件 :
操作
操作
elif 条件 :
操作
操作
elif 条件 :
操作
操作
else:
操作
操作
空语句
pass
a = int(input("请输入一个整数:"))
if a == 1:
print("hello")
a = int(input("请输入一个整数:"))
if a != 1:
pass
else:
print("hello")
上面两种实现方式是等价的
循环语句
while 条件 :
循环内容
循环内容
# 例子 打印 1 ~ 10
num = 1
while num <= 10:
print(num)
num += 1
for 循环变量 in 可迭代对象:
循环内容
循环内容
# 例子 打印 1 ~ 10
for i in range(1, 11):
print(i)
break 跳出循环 结束整个循环
continue 跳过本次循环 进入下次循环
函数
函数定义 函数调用
# 定义函数
def 函数名(参数):
函数内容
函数内容
return 返回值
# 调用函数
函数名(参数)
# 定义函数
def add(x, y):
return x + y
# 调用函数
sum(1, 1)
参数默认值
可以给参数设置初始值
def add(x = 1, y = 1):
return x + y
print(add())
print(add(5, 5))
关键字传参
def test(x, y):
print(f'x = {x}')
print(f'y = {y}')
test(x=10, y=20)
test(y=100, x=200)
列表
多个元素的一个顺序集合
创建列表
alist = []
alist = list()
列表可以存放不同类型的元素
alist = [1, 0.5, "hello", True]
访问元素
通过下标访问符 ’ [ ] ‘ 来获取列表中的元素,列表的下标从 0 开始
下标可以为负数,表示倒数,-1 为 倒数第一
alist = [1, 2, 3, 4, 5]
print(alist[2])
修改元素
alist = [1, 2, 3, 4, 5]
alist[2] = 6
print(alist[2])
切片操作
将列表切出一个子列表,使用 [ : ] 进行切片
alist = [1, 2, 3, 4, 5]
print(alist[1:4])
从列表的 1 下标开始,到 4 下标前停下,即 [1, 4) 前闭后开区间
其他切法
省略前后边界
print(alist[1:]) # 省略后边界, 表示获取到列表末尾
print(alist[:-1]) # 省略前边界, 表示从列表开头获取
print(alist[:]) # 省略两个边界, 表示获取到整个列表
设置步长
alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(alist[::1])
print(alist[::2])
print(alist[::3])
print(alist[::5])
alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(alist[::-1])
print(alist[::-2])
print(alist[::-3])
print(alist[::-5])
遍历列表
for elem in alist:
print(elem)
for i in range(0, len(alist)):
print(alist[i])
i = 0
while i < len(alist):
print(alist[i])
i += 1
新增元素
append 方法,向列表的最后添加一个元素
alist.append('hello')
insert 方法,向列表中的指定下标位置插入一个元素,原来的元素向后移
# 在 1 下标处插入 hello
alist.insert(1, 'hello')
查找元素
in 操作符可以判定元素是否在列表中,返回布尔类型
alist = [1, 2, 3, 4]
print(2 in alist)
print(5 in alist)
index 方法,查寻元素在列表中的下标。若不存在,则抛出异常
alist = [1, 2, 3, 4]
print(alist.index(2))
print(alist.index(5))
删除元素
pop 方法可以删除最末尾的元素
alist = [1, 2, 3, 4]
alist.pop()
print(alist)
pop 方法按照下标删除
alist = [1, 2, 3, 4]
alist.pop(2)
print(alist)
remove 方法直接移除对应元素
alist = [1, 2, 3, 4]
alist.remove(2)
print(alist)
列表连接
+ 号连接 会生成一个新的列表,不会影响到旧列表
alist = [1, 2, 3, 4]
blist = [5, 6, 7]
print(alist + blist)
extend 方法连接,把一个列表拼接到另一个列表的后面
alist = [1, 2, 3, 4]
blist = [5, 6, 7]
alist.extend(blist)
print(alist)
print(blist)
元组
列表和元组是十分相似的,只是列表中存放的元素是可以修改的,而元组中存放的元素是在创建时就确定下来的不能修改
元组创建
atuple = ()
atuple = tuple()
元组支持:下标访问、切片操作、遍历、in、index、+ 等
元组不支持:修改元素、新增元素、删除元素、extend 等
字典
字典用于存储键值对,键 key 的类型可以是各种类型
创建字典
a = { }
b = dict()
print(type(a))
print(type(b))
设置键值对
键值对之间使用 ' , ' 隔开
键与值之间使用 ' : ' 隔开
student = { 'id': 1, 'name': 'zhangsan' }
print(student)
查找元素
使用 in 判断 key 是否在字典中存在
student = {
'id': 1,
'name': 'zhangsan',
}
print('id' in student)
print('score' in student)
使用 [ ] ,通过 key 获取 value
student = {
'id': 1,
'name': 'zhangsan',
}
print(student['id'])
print(student['name'])
新增/修改元素
使用 [ ] ,通过 key 修改 value,如果 key 不存在则在字典中新增该元素
student = {
'id': 1,
'name': 'zhangsan',
}
student['score'] = 90
print(student)
student = {
'id': 1,
'name': 'zhangsan',
'score': 80
}
student['score'] = 90
print(student)
删除元素
使用 pop 方法,通过 key 删除对应元素
student = {
'id': 1,
'name': 'zhangsan',
'score': 80
}
student.pop('score')
print(student)
遍历字典元素
使用 for 循环,获取 key ,通过 key 访问 value
student = {
'id': 1,
'name': 'zhangsan',
'score': 80
}
for key in student:
print(key, student[key])
获取字典中的 key 和 value
使用 keys 方法可以返回一个类似元组的 dict_keys 类型,它会包含字典中的所有 key 值
student = {
'id': 1,
'name': 'zhangsan',
'score': 80
}
print(student.keys())
使用 values 方法也是返回一个类似元组的 dict_values 特殊类型
student = {
'id': 1,
'name': 'zhangsan',
'score': 80
}
print(student.values())
使用 items 方法,获取到字典内的所有键值对
student = {
'id': 1,
'name': 'zhangsan',
'score': 80
}
print(student.items())
文件
打开文件
使用 open 函数打开文件
f = open('d:/test.txt', 'r')
第一个参数为路径
第二个参数为打开方式,' r ' 读、' w ' 写、' a ' 追加
关闭文件
使用 close 方法关闭打开的文件
f.close()
写文件
使用 write 方法将数据写入文件中
f = open('d:/test.txt', 'w')
f.write('hello')
f.close()
' r ' 方式使用 write 方法会报错,抛出异常
' w ' 方式使用 write 会覆盖原有的内容
' a ' 方式使用 write 在原本的内容后面追加内容
f = open('d:/test.txt', 'w')
f.write('hello')
f.close()
f = open('d:/test.txt', 'a')
f.write('world')
f.close()
读文件
使用 read 方法从文件中读取数据
f = open('d:/test.txt', 'r')
result = f.read(2)
print(result)
f.close()
参数为读取多少个字符
多行文本可使用 for 循环一行一行读
f = open('d:/test.txt', 'r')
for line in f:
print(f'line = {line}')
f.close()
使用 readlines 将整个文件读取出来,返回一个列表
f = open('d:/test.txt', 'r')
lines = f.readlines()
print(lines)
f.close()
上下文管理器
上下文管理器可以关闭我们忘记关闭的文件
使用 with 语句打开文件,当 with 内的代码执行完毕后,就会自动关闭方法
with open('d:/test.txt', 'r', encoding='utf8') as f:
lines = f.readlines()
print(lines)