【Python】Python语法速成

最新推荐文章于 2024-04-29 17:55:25 发布

蒋灵瑜

最新推荐文章于 2024-04-29 17:55:25 发布

阅读量418

点赞数 5

分类专栏： Python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/gfdxx/article/details/134131426

版权

Python 专栏收录该内容

1 篇文章 1 订阅

订阅专栏

一、Python中的概念

二、Python和C/C++中的一些不同点

5、使用第三方库xlrd/xlwc操作excel

6、使用第三方库playsound/pynput制作程序员鼓励师

7、学生管理系统

一、Python中的概念

在PyCharm选中变量按shift + F6可以整体替换变量名

1 + 2 + 3 称为表达式
1 2 3这样的数字称为字面值常量
+ - * /称为运算符或操作符
print(3 ** 2) #3的平方（乘方）
print(3 ** 5) #3的五次方（乘方）
print(3 ** 0.5) #3的0.5次方（开方）
print(7 // 3) #//代表向下取整算法，打印2
print(-7 // 3)#//代表向下取整算法，打印-3

print(type(a)) #查看a的类型，python中变量的类型在其初始化赋值的时候确定。
print(len(s)) #字符串s的长度
a:int = 1 #在声明变量时，可以指明变量类型（锦上添花行为）

#python格式化字符串，输出字符串"a = 20",
#其中的f代表format格式化的意思，此时就可以使用{}往字符串中嵌入变量或表达式
a = 10
print(f"a = {a + 10}")

num = input("请输入数字") #python中的输入，从键盘输入一个值赋值给num
num = int(num) #num的类型是str，如果要将num用于计算，需先类型转换

a = b = 10 #链式赋值
a, b = 10, 20 #多元赋值，10赋值给了a，20赋值给了b。同理a, b = b, a可用于交换变量

python中的内建函数len()可以传字符串、列表、元组、字典、自定义类的长度。（原理：动态类型）

二、Python和C/C++中的一些不同点

1、print(2 / 3)#0.6666666666666666

python的浮点数在内存中的存储和C/C++一样，同样遵照IEEE754标准

2、python中int范围是无穷的（自动扩容，取决于内存够不够），所以python中没有byte、short、long等类型。int占用4个字节，可能会扩容。

3、python中的float就是双精度浮点数。所以python中也没有double关键字。float占8个字节。

4、python中的string类型是str。特有的三引号s = """My 'name' is "jly" """

5、python中布尔类型开头大写，True/False。布尔也占一个字节。

6、在程序运行过程中，一个变量的类型是动态的，会随着赋值类型的改变而改变。

7、使用#进行单行注释或三引号进行文档注释。

8、python可以直接使用==和!=来比较字符串的内容是否相等。C/C++使用==或!=则会去比较字符串的地址。注意浮点数使用==或者!=进行比大小，由于浮点数在内存中的存储规则，可能会引发误判！！！

9、python可以进行连续比较。

10、python中的and、or、not即为与、或、非，对应C/C++中的&&、||、!

11、python不支持++、--这种自增、自减操作

12、python中存在身份运算符（is、is not）、成员运算符（in、 not in）

13、在python中-19 % 2等于1，而C/C++等于-1

三、分支语句

try:
    a = int(input("输入1认真学习，输入2摆烂：")) #注意input输入的是字符串
    if a == 1:
        print("认真学习")
    elif a == 2:
        print("摆烂")
    else:
        pass
except ValueError:
    print("输入无效，请输入 1 或 2")

可以使用pass充当空语句；try + except捕获异常。python中没有switch关键字。

四、for循环

for 循环遍历 in 可迭代对象:

循环体

#打印1-10
for i in range(1, 11):
    print(i)
#打印1,3,5,7,9
for i in range(1, 11, 2):
    print(i)

range也是一个内建函数，效果是获得一个包含一系列成员的可迭代对象。range(begin, end)等价于[begin,end),第三个参数代表遍历时的步长，步长默认是1，如果想从10到1倒着遍历，步长可以给负数。

五、函数

在python中，只有函数和类中的变量才会涉及作用域，其他地方定义的变量均为全局变量。

python特有的一个函数返回多个值：

def GetPoint():
    x = 10
    y = 20
    z = 30
    return x, y, z


a, b, c = GetPoint() # 返回值整体接收
_, _, d = GetPoint() # 返回值部分接收，使用_来进行占位

想要在python中修改全局变量，必须在函数体中使用global将变量声明为全局变量：

x = 10


def Test():
    global x  
    x = 20  # 如果没有global x，那么这里的x将会被当做在函数中创建变量x
    print(x)


Test()  # 打印20

python函数的关键字传参

def Test(x, y):
    print(f"x = {x},y = {y}")


Test(x = 10, y = 30)  # 打印x = 10,y = 30
Test(y = 20, x= 5)  # 打印x = 5,y = 20

python函数的关键字传参和位置传参混用，位置传参必须在前：

六、列表[]

列表是可变的：创建好之后，随时能改。一个列表可以存储多种类型。

元组是不可变的：创建好之后，无法修改，只能丢弃旧的，重新弄个新的。

1、列表

# 创建列表
# 1、直接使用字面值创建
a = []  # []就表示一个空的列表

# 2、使用list()来创建列表
b = list()

# 3、创建列表时，在[]中指定列表的初始值
c = [1, True, [4, 5, 6], "abc"]

# 4、使用内建函数len来获取列表的长度
print(len(c))  # 打印4

# 5、python中的下标，可以写成负数。a[-1]等价于a[len(a) - 1]，代表打印最后一个元素
print(c[len(c) - 1])  # 打印abc
print(c[-1])  # 打印abc

2、切片

切片是一个高效的操作，只是取出了原列表中的一部分，不涉及数据的拷贝。

# 1、切片基本用法：左闭右开
a = [1, 2, 3, 4]
print(a[1:3])    # 左闭右开，打印[2, 3]

# 2、省略边界的切片
print(a[1:])     # 打印[2, 3, 4]
print(a[:3])     # 打印[1, 2, 3]
print(a[:])      # 打印[1, 2, 3, 4]
print(a[:-1])    # 打印[1, 2, 3]右边界是倒数第一个元素
print(a[0:100])  # 打印[1, 2, 3, 4]，切片可以越界

# 3、带有步长的切片
print(a[::2])    # 打印[1, 3], 第一个:是切片，第二个:是步长
print(a[::-2])   # 打印[4, 2]，步长是负数，从后往前取

3、列表的遍历

# 1、使用for循环遍历列表
a = [1, 2, 3, 4, 5]
for elem in a:
    print(elem)  # 若此处修改elem的值，并不会改变列表a中对应的元素

# 2、使用for循环控制执行次数，循环体内下标遍历
for i in range(0, len(a)):
    print(a[i])  # 若此处修改a[i]的值，可以改变列表a中对应的元素

# 3、使用while循环通过下标进行遍历
i = 0
while i < len(a):
    print(a[i])

4、列表的插入

# 1、使用append往列表末尾新增一个元素
a = [1, 2, 3, 4]
a.append("hello")

# 2、使用insert向列表任意位置进行插入
a.insert(1, "new data")  # 在下标为1的位置插入字符串

5、in/not in/index

a = [1, 2, 3, 4]
print(1 in a)   # 使用in、not in判断某个元素是否存在于列表
m = a.index(2)  # 在列表中找到元素2的下标并返回，如果找不到将抛出异常

6、列表的删除

# 1、使用pop删除列表末尾的元素
a = [1, 2, 3, 4]
a.pop()   # a为[1, 2, 3]
a.pop(1)  # 删除下标为1的元素，a为[1, 3]

# 2、使用remove，按照值进行删除
a = [1, 2, 3, 4]
a.remove(2)  # a为[1, 3, 4]

7、列表的拼接

# 1、使用+对两个列表进行拼接
a = [1, 2, 3, 4]
b = [5, 6]
c = b + a
print(c)  # 打印[5, 6, 1, 2, 3, 4]

# 2、使用extend对两个列表进行拼接
# 后一个列表会被拼接到前一个列表末尾，这种方法对前一个列表进行修改
m = a.extend(b)
print(a)  # 打印[1, 2, 3, 4, 5, 6]
print(m)  # 打印None
# 3、使用+=对列表进行拼接,效果和extend一样，但extend更高效
a = [1, 2, 3, 4]
b = [5, 6]
a += b
print(a)  # 打印[1, 2, 3, 4, 5, 6]

七、元组()

元组不支持修改操作！！！对于元组这种不可变对象，是可以作为哈希的key值的。

# 1、创建元组
a = ()
b = tuple()

# 2、创建元组的时候，指定初始值
c = (1, [1, 3], "hello", (5, 1, 3))
print(c)  # 打印(1, [1, 3], 'hello', (5, 1, 3))

# 3、通过下标访问元组中的元素
print(c[1])    # 打印[1, 3]
print(c[-2])   # 打印hello
print(c[100])  # 访问越界，抛出异常

# 4、通过切片获取元组中的一部分
print(c[1:3:1])  # 打印([1, 3], 'hello')
# 5、也可以使用循环遍历元素、in/not in判断元素是否存在、index查找下标

# 6、使用+拼接两个元组
d = (1, 2, 3)
e = (4, 5, 6)
f = d + e
print(f)  # 打印(1, 2, 3, 4, 5, 6)

当进行多元赋值的时候，本质上是按照元组的方式进行工作的：

def GetPoint():
    x = 10
    y = 20
    return x, y


m, n = GetPoint()  # 多元赋值，本质是使用了元组

八、字典{}

字典中的key不能重复。对于字典来说，使用in或者[]来获取value，都是非常高效的。（底层是哈希表，擅长增删改查，不擅长遍历）

1、字典的基本使用

在C++和java中，哈希表中的键值对存储的顺序，是无序的，但在Python中，遍历出来的顺序即为插入的顺序。（做了特殊处理）

# 1、创建字典
a = {}
b = dict()

# 2、创建字典的同时设置初始值，key的类型可以不统一
c = {
    "id": 1,
    "name": "张三",
    100: "李四",
    (1, 2, 3): "王五"
}

# 3、使用in来判定某个key是否在字典中存在
print((1, 2, 3) in c)  # 打印true

# 4、使用[]来根据key获取value
print(c["name"])  # 打印张三，若key不存在，则抛出KeyError异常

# 5、在字典中新增键值对/修改键值对（key不存在则新增，存在则为修改）
c['score'] = 50  # 新增键值对
c["id"] = 999    # 修改键值对

# 6、使用pop方法，根据key删除键值对
c.pop("id")

# 7、使用for循环遍历字典
for key in c:
    print(key, c[key])

# keys()获取字典中的所有key；values获取字典中的所有values；items获取字典中的所有键值对
print(c.keys())    # 打印dict_keys(['name', 100, (1, 2, 3), 'score'])
print(c.values())  # 打印dict_values(['张三', '李四', '王五', 50])
print(c.items())   # 打印dict_items([('name', '张三'), (100, '李四'), ((1, 2, 3), '王五'), ('score', 50)])

for key, value in c.items():  # c.items()返回一个列表，列表中的每一个元素是元组，这里是元组的多元赋值
    print(key, value)

2、合法的key类型

字典的本质是一个哈希表，哈希表的key值要求是可哈希的，不能改的。

# 使用hash()函数能够计算出一个变量的哈希值
print(hash(0))
print(hash(3.14))
print(hash("hello"))
print(hash(True))
print(hash((1, 2, 3)))

# 有的类型是不能计算哈希值的
print(hash([1, 2, 3]))  # 列表不能计算哈希值，因为列表可修改，无法作为key
print(hash({}))         # 字典不能计算哈希值，因为字典可修改，无法作为key