【Python】基本语法

数据类型

通过 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:passelse:print("hello")

上面两种实现方式是等价的 

循环语句

while 条件 :循环内容循环内容# 例子 打印 1 ~ 10
num = 1while 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 + yprint(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)