【python语法基础篇2】

最新推荐文章于 2025-07-13 22:32:50 发布

七七w77

最新推荐文章于 2025-07-13 22:32:50 发布

阅读量744

点赞数 15

CC 4.0 BY-SA版权

文章标签： python 开发语言

本文链接：https://blog.csdn.net/qq_73630485/article/details/149280523

列表

1.定义：是处理一组有序项目的数据结构

2.格式：列表名 = [元素1，元素2，元素3，…]

注意：列表的所有元素放在[]中，并使用逗号隔开。

一个列表中的数据类型可以不相同

列表的常见操作

1.添加元素

append（）整体添加

a = ['one','two','three']
a.append("four")
print(a)  # 输出：['one', 'two', 'three', 'four']

extend（）分散添加，将元素逐一添加

a = ['one', 'two', 'three']
a.extend(["four"])  # 传递列表形式，避免字符串被拆分
print(a)  # 输出: ['one', 'two', 'three', 'four']

insert（）在指定位置加入元素

a = ['one', 'two', 'three']
a.insert(2, "four")
print(a)  # 输出: ['one', 'two', 'four', 'three']

2.修改元素

直接通过下标修改

a = [1, 2, 3]
a[1] = 'a'
print(a)  # 输出: [1, 'a', 3]

3.查找元素

in：判断指定元素是否存在列表中，如果存在就返回True，不存在就返回False

not in：判断指定元素是否存在列表中，如果不存在就返回True，存在就返回False

a = ['a', 'b', 'c', 'd']
print('a' in a)  # True
print('b' not in a)  # False

# 定义一个列表，保存已经存在的昵称
name_list = ['lufei', 'namei', 'suonong']

while True:
    name = input("请输入您的昵称:")
    # 判断昵称是否存在
    if name in name_list:
        print(f"您输入的昵称{name}已经存在")
    # 如果昵称不存在
    else:
        print(f"昵称{name}已被您使用")
        # 把新的昵称新增到列表
        name_list.append(name)
        print(name_list)
        break

用户输入昵称，昵称重复则不能使用。

# 定义一个列表，保存已经存在的昵称
name_list = ['lufei', 'namei', 'suonong']

while True:
    name = input("请输入您的昵称:")
    # 判断昵称是否存在
    if name in name_list:
        print(f"您输入的昵称{name}已经存在")
    # 如果昵称不存在
    else:
        print(f"昵称{name}已被您使用")
        # 把新的昵称新增到列表
        name_list.append(name)
        print(name_list)
        break

index：返回指定数据所在位置的下标，如果查找的数据不符合就会报错。

count：统计指针在当前列表出现的次数。

跟字符串中的用法相同

4.删除元素

del

a = [1, 2, 3]  # 初始化列表
del a[1]       # 删除索引为1的元素（值为2）
print(a)       # 输出结果：[1, 3]

# del a # 删除列表a

pop：删除指定下标的数据，默认删除最后一个元素

a = [1, 2, 3, 4, 5]
a.pop(2)  # 删除下标为2的元素（值为3）
print(a)  # 输出结果为[1, 2, 4, 5]

remove：根据元素的值进行删除

a = [1, 2, 3, 4, 5]
a.remove(3)  # 删除第一个值为3的元素
print(a)  # 输出[1, 2, 4, 5]

5.排序

sort：将列表按指定顺序重新排列，默认从小到大

a = [4, 1, 7, 9, 3, 2, 0]
a.sort()
print(a)  # 输出: [0, 1, 2, 3, 4, 7, 9]

reverse：将列表倒置（反过来）

a = [4, 1, 7, 9, 3, 2, 0]
a.reverse()
print(a)  # 输出: [0, 2, 3, 9, 7, 1, 4]

6.列表推导式

基本写法：

[表达式 for 变量 in 列表]

[表达式 for 变量 in 列表 if 条件]

注：in后可放列表，rang（），可迭代对象

格式1

a = [1,2,3,4,5,6,7]

[print(i*5) for i in a] #前一个i是表达式，

#输出结果

# 10

# 15

# 20

# 25

# 30

# 35

a = []
[a.append(i) for i in range(1,6)]
print(a)  # 输出: [1, 2, 3, 4, 5]

格式2

#把基数放进列表里

a = []
[a.append(i) for i in range(1,10) if i%2==1]
print(a)  # [1, 3, 5, 7, 9]

7.列表嵌套

含义：一个列表里又有一个列表

a = [1,2,3,[4,5,6]] #[4,5,6]是里面的列表

print(a[3]) #[4, 5, 6] 取出里面的列表

print(a[3][0]) #4 取出内列表中的列表

元组

格式：元组名 = （元素1，元素2，…) a = （1,2,3）

注意：定义元组时，如果只有一个元素，末尾要加逗号，多个元素用逗号隔开，元素可以是不同类型的。只有一个元素的时候末尾要加上逗号

元组与列表区别

元组只有一个元素末尾必须加逗号，列表不需要
元组只支持查找操作

a = (1,2,3)

print(a[2]) # 3

count（），index（），len（）跟列表的用法相同

应用场景

函数的参数和返回值

格式化输出后面的（）本质上就是一个元组

name = 'suonong'
age = 18
print("%s的年龄是：%d"%(name,age))  # suonong的年龄是：18

info = (name,age)  
print(type(info))  # <class 'tuple'>
print("%s的年龄是：%d"%info)  # suonong的年龄是：18

数据不可以被修改，保护数据的安全

字典

格式：字典名 = {键1：值1,键2,：值2…} dic = {'name':'lufei','age':18}

注意：键值对形式保存，键具有唯一性，但值可以重复。类型：dict

键名重复，前面的值会被后面的值覆盖

不可以根据下标，字典中没有下标

1.查询：方式一变量名[键名]

dic = {'name':'lufei','age':18}
print(dic["age"])  # 输出：18

方式二变量名.get(键名)

dic = {'name':'lufei','age':18}
print(dic.get("name")) #lufei
print(dic.get("tel")) #键名不存在时返回None
print(dic.get("tel",'不存在')) #不存在 如果不存在可返回自己设置的默认值

2.修改：通过键名修改

格式：变量名[键名] = 值

# 原始字典
dic = {'name':'lufei','age':18}

# 修改age键的值为20
dic['age'] = 20

# 打印修改后的字典
print(dic)  # 输出: {'name': 'lufei', 'age': 20}

3.添加：

格式：变量名[键名] = 值

注意：键名存在就修改，不存在就新增

dic = {'name':'lufei','age':18}

dic['tel'] = 12345

print(dic) #{'name': 'lufei', 'age': 18, 'tel': 12345} 新增

dic['tel'] = 67890

print(dic) #{'name': 'lufei', 'age': 18, 'tel': 67890} 修改

4.删除：

del 方式一： del 字典名删除整个字典

方式二： del 字典名[键名]

dic = {'name': 'lufei', 'age': 18}
del dic['name']
print(dic)  # 输出: {'age': 18}

clear（）清空整个字典里面的东西，保留字典

dic.clear()

pop()删除指定键值对，键不存在就会报错

dic.pop("age")

5.求长度：len（dic）

6.返回字典里面的所有键名：key（） dic.key()

7.返回字典里面包含的所有值:values() dic.values()

8.返回字典里包含的所有键值对：items（） dic.items()

应用场景：

使用键值对，存储描述一个物体的相关信息

集合

格式：集合名 = {元素1，元素2，…} s1 = {1,2,3} s1 = set（）定义空集合

注意：集合是无序的，里面的元素是唯一的。

可以用于元组或者列表去重。

无序性：每次运行结果顺序都不一样，数字运行结果一样

唯一性：可以自动去重

s1 = {1,1,2,2,3,3}

print(s1) #{1, 2, 3}

集合的常见操作

1.添加

add()：添加一个整体

s1 = {1, 2, 3, 4}
s1.add(5)  # 添加单个元素5
print(s1)  # 输出: {1, 2, 3, 4, 5}

s1.add((5, 6))  # 添加元组(5,6)作为一个整体元素
print(s1)  # 输出: {1, 2, 3, 4, 5, (5, 6)}

update()：把元素拆分放入集合

s1 = {1, 2, 3, 4}
s1.update('567')
print(s1)  # 输出: {1, 2, 3, 4, '5', '6', '7'}

2.删除

remove（）：选择删除的元素，如果集合中有就删除，没有会报错

s2 = {1, 2, 3, 4}
s2.remove(2)
print(s2)  # 输出: {1, 3, 4}

pop（）：默认删除删除第一个元素

discard():选择删除的元素，如果集合中有就删除，没有不会发生改变

3.交集和并集

交集&：共有的部分，没有就返回set（）空集

a = {1,2,3,4}

b = {3,4,5,6}

print(a&b) #{3, 4}

并集 | ：所有的元素放一起，重复的不算

a = {1,2,3,4}

b = {3,4,5,6}

print(a|b) #{1, 2, 3, 4, 5, 6}

类型转换

int(x)——将x转换为一个整数

float(x)——将x转换为一个浮点数

str(x)——将x转换为字符串

eval(str)——用于计算在字符串中的有效python表达式，并返回一个对象

tuple(s)——将序列s转换为一个元组

list(s)——将序列s转换为一个列表

chr(x)——将一个整数转换为一个字符

深浅拷贝

赋值：完全共享资源，一个值的改变会完全被另一个值共享。

a = [1, 2, 3, 4]
print(a)
b = a
print(b)

浅拷贝：数据半共享，会创建新的对象，拷贝第一层的数据，嵌套层会指向原来的内存地址。

import copy  # 导入copy模块

a = [1, 2, 3, [4, 5, 6]]
b = copy.copy(a)  # 浅拷贝

# 查看内存地址
print("a的内存地址：", id(a))  # 2581532316032
print("b的内存地址：", id(b))  # 2581534767936
print("a[3]内存地址：", id(a[3]))  # 2193373862080
print("b[3]内存地址：", id(b[3]))  # 2193373862080

外层的内存地址不同，但是内层的内存地址相同

优点：拷贝速度快，占用空间少，拷贝效率高

深拷贝：数据完全不共享，外层内部的元素都拷贝了一遍

import copy
a = [1,2,3,[4,5,6]]
b = copy.deepcopy(a)
print("a的内存地址：",id(a)) #1999675724160
print("b的内存地址：",id(b)) #1999677913920
print("a[3]内存地址：",id(a[3])) #1999675726016
print("b[3]内存地址：",id(b[3])) #1999678827520

外层内层的内存地址都不同

可变类型

含义：变量对应的值可以修改，但是内存地址不会发生改变

常见的可变类型：list，dict，set，append

a = [1, 2, 3, 4]
print("a的原内存地址：", id(a))  # 输出原内存地址
a.append(5)
print(a)  # 输出修改后的列表
print("a的现内存地址：", id(a))  # 输出操作后内存地址

不可变类型

含义：变量对应的值不可以修改，如果修改就会生成一个新的值从而分配新的内存空间

a = 10  #整形  
print("原地址", id(a))  #原地址 140709871749848  
a = 15  
print("现地址", id(a))  #现地址 140709871750008

函数

定义：将具有独立功能的代码组织成一个整体，使其具有特殊功能的代码集。

作业：使用函数可以加强代码的复用性，提高程序编写的效率。

结构：def 函数名（）：

函数体

注意：函数名要符合标识符规定，最好见名知意。

def login():

print("这是登录函数")

print("——")

调用几次，函数里面的代码就会运行几次，每次调用的时候，函数就会从头开始执行

返回值return

定义：函数执行结束后，最后给调用者的一个结果。

作用：

return会给函数的执行者返回值

def buy():

return "你好"

print(buy()) #你好需要打印才能看到返回值

函数中遇到return，表示子函数结束，不继续执行
返回值的3种情况
1. 没有返回值，结果为None
2. 一个返回值，就把返回值给调用者
3. 多个返回值，以元组的形式返回给调用者

return和print的区别：

1.return表示此函数结束，print会一直执行

2.return返回计算值，print打印结果

参数

形参：函数定义时的参数，仅在函数体内有效

实参：函数调用时使用的参数，该值将传递给函数

格式：def 函数名（形参1，形参2）：

函数体

…（如a = 1 b = 2）

调用格式：函数名（实参1，实参2）

def add(a,b): #定义函数

return a+b

print(add(1,2)) #3 调用函数

函数参数

必备参数（位置参数）：传递和定义参数的顺序及个数必须一致。写了几个传几个。

格式：def cs（a，b，c）

def cs(name1,name2,name3):

print(name1)

print(age)

print(sex)

cs('lufei','18','女')

默认参数：为参数提供默认值，调用参数时可不传该默认参数的值。

注意：所有的位置参数必须出现在默认参数前，包括函数定义和调用。

格式：def wen（a = 10）：设置默认值，没有传值会根据默认值执行代码，传了值根据传入的值来执行代码。

def wen(a=8):

print(a)

wen() #8

wen(19) #19

可变参数：传入的值是可变的，可以传入多个，也可以不传

格式： def wen（*args）

def wen(*args):

print(args) #以元组的形式接收

wen(1,2,3,4,5)

关键字参数：**kwarge接受所有的关键字参数然后将其转换成一个字典赋值给kwarges。

格式：de wen（**kwarge）

def wen(**kwargs):

print(kwargs)

wen(name = 'lufei', age = 18) #必须以字典的形式传值

函数嵌套

4.1嵌套调用

含义：在一个函数里面调用另一个函数

def study():
    print("Study")

def course():
    study()
    print("Course")
course()

嵌套定义：在一个函数中定义另一个函数

def study():  # 外函数
    print("Study")
    def course():  # 内函数
        print("Course")
    course()  # 在内函数定义后调用

study()  # 调用外函数

#注意缩进，定义和调用是同级的，调用如果在定义里面则永远用不到

注意：不要在内层函数中调用外层函数，会陷入死循环，直到超过递归的最大深度