Python基础知识（基础语法二）

函数

函数定义

"""
函数的定义:
def 函数名(传入参数)函数体return 返回值
"""

无参函数

def test():print("hello world")
"""
调用
"""
test()

有参函数

# 定义函数
def add(x,y):return x+y
# 定义变量接收函数
result = add(5,6)
# 输出结果
print(result)

• 函数定义中，提供的x和y，称之为:形式参数(形参)，表示函数声明将要使用2个参数参数之间使用逗号进行分隔
• 函数调用中，提供的5和6，称之为:实际参数(实参)，表示函数执行时真正使用的参数值传入的时候，按照顺序传入数据，使用逗号分隔
• 传入参数的数量是不受限制的。可以不使用参数也可以仅使用任意N个参数

None类型

定义变量接收没有返回内容的函数就会得到一个None
None 类似与null

def test():print("test")result = test()print(f"result 返回的内容是{result}")
print(f"result 返回的类型是{type(result)}")
===============运行结果==================
test
result 返回的内容是None
result 返回的类型是<class 'NoneType'>

None类型应用场景

在if判断中

1. 在if判断中，None等同于False一般用于在函数中主动返回None，配合if判断做相关处理

def check_age(age):if age >= 18:return "ok"else:return Noneresult = check_age(16)
if result :print("你已成年")
else:print("小屁孩")

定义变量

None用于声明无初始内容的变量

name = None

函数使用说明文档

在函数内部使用注释，会自动列出所有参数和返回，可以有效的对函数进行说明

函数嵌套调用

函数嵌套调用：函数内部调用函数

def A():print('调用了函数A')def B():print('调用了函数B')A()print("函数B调用结束")
print("开始调用函数B")
B()
============结果展示==============
开始调用函数B
调用了函数B
调用了函数A
函数B调用结束

变量在函数中的作用域

局部变量

• 函数内定义的叫局部变量

所谓局部变量是定义在函数体内部的变量，即只在函数体内部生效

# 定义函数，函数中定义局部变量
def A():num = 10print(num)def B():num = 20print(num)A()
B()
# 输出结果
# 10
# 20

全局变量

• 函数外定义的叫全局变量

所谓全局变量，指的是在函数体内、外都能生效的变量

# 定义全局变量
a = 100
# 定义函数
def plausA():# 函数中修改全局变量a = 109# 输出全局变量print(a)def plausB():a = 101print(a + 1)
# 调用函数
plausA()
plausB()
# 函数外输出全局变量
print(a)
# 输出结果：
# 109
# 102
# 100

函数内可以对全局变量修改，但只在该函数中生效，不会影响该变量的值

global 关键字

• 使用global关键字可以在函数内部声明变量为全局变量

# 定义函数，函数中定义局部变量
numB = 100def A():# 使用global 关键字定义全局变量global numAnumA = 10print(f"A方法内输出的全局变量numA：{numA}")def B():global numBnumB = 200num = 20print(f"B方法内输出的局部变量num：{num}")# 调用全局变量 numAprint(f"B方法内输出A方法内定义的全局变量numA：{numA}")
A()
B()
# 方法外也可以输出global修饰之后的变量
print(f"方法外输出的A方法内定义的全局变量numA：{numA}")
print(f"方法外输出的全局变量numB：{numB}")
# A方法内输出的全局变量numA：10
# B方法内输出的局部变量num：20
经过global 修饰的全局变量 在其他函数中也能调用
# B方法内输出A方法内定义的全局变量numA：10
经过global 修饰的全局变量 在函数外也能调用
# 方法外输出的A方法内定义的全局变量numA：10
# 全局变量在函数内经过global修饰之后 在该函数中的修改也会影响原本的数值
# 方法外输出的全局变量numB：200

数据容器

• Python中的数据容器:
  一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素每一个元素，可以是任意类型的数据，如字符串、数字、布尔等

类型	描述	说明
列表(List)	有序的可变序列	python中使用最频繁的数据类型，可有序记录一堆数据
元组(Tuple)	有序的不可变序列	可有序记录一堆不可变的Python数据集合
集合(Set)	无序不重复集合	可无序记录一堆不重复的Python数据集合

列表

定义

# 定义
list = ["张三","李四","王五","赵六"]
print(list)
print(type(list))# 元素数据类型没有限制
list = ["张三",234,True,list]
print(list)
print(type(list))

下标索引

• 列表的每一个元素都有编号称之为下标索引
• 列表的下表索引是从前向后从0开始依次累加的
  

# 定义列表
list = ["张三","李四","王五","赵六"]
# 按照正向索引依次输出元素
print(list[0])
print(list[1])
print(list[2])
print(list[3])
===========结果展示=============
张三
李四
王五
赵六

也可以从后向前从-1开始依次累减

# 定义列表
list = ["张三","李四","王五","赵六"]
# 按照反向索引依次输出元素
print(list[-1])
print(list[-2])
print(list[-3])
print(list[-4])
===========结果展示=============
赵六
王五
李四
张三

嵌套列表

# 定义嵌套列表
list = [[1,2,3],[4,5,6],[7,8,9]]
# 使用索引取出对应元素
# 取出 5
# 5对应着 第二个元素列表中的第二个元素
print(list[1][1])=========这样也可以==========
# 定义嵌套列表
first = [1,2,3]
second = [4,5,6]
third = [7,8,9]
list = [first,second,third]
# 使用索引取出对应元素
# 取出 5
# 5对应着 第二个元素列表中的第二个元素
print(list[1][1])

操作列表的常用方法

方法	描述
list.index(元素)	查找元素所在列表中的索引
list[索引] =value	修改特定索引的值
list.insert(索引,元素)	指定下标位置插入元素
list.append(元素)	在列表尾部添加一个元素
list.extend(列表)	在列表尾部添加一批元素
del list[索引]	删除指定索引元素
list.remove(元素)	删除指定元素第一个匹配项
list.pop(索引)	删除指定索引元素
list.count(元素)	统计列表中某元素数量
len(list)	统计列表中全部元素数量
list.clear()	清空列表

# 定义列表
list = ["你好",12,"你好","我是小美","我是小昕"]
# 查找元素所在列表中的索引
result = list.index("我是小昕")
print(result)
# 修改特定索引的值
list[2] = "谢谢"
print(list)
# 指定下标位置插入元素
list.insert(1,"我来插队")
list.insert(1,"你好")
print(list)
# 在列表尾部添加一个元素
list.append("我是最后一个")
print(list)
# 在列表尾部添加一批元素
add = [1,2,3]
list.extend(add)
print(list)
# 删除指定索引元素
del list[2]
print(list)
# 删除指定元素第一个匹配项
list.remove("你好")
print(list)
# 删除指定索引元素
list.pop(-1)
print(list)
# 统计列表中某元素数量
count = list.count("你好")
print(count)
# 统计列表中全部元素数量
count = len(list)
print(count)
# 清空列表
list.clear()
print(list)

列表遍历

while

语法

index = 0
while index < len(列表)元素= 列表[index]元素处理index +=1	

示例

# 定义列表
list = ["你好",12,"你好","我是小美","我是小昕"]index = 0
while index < len(list):item = list[index]print(item)index += 1

for

语法

for 临时变量 in 数据容器 :对临时变量处理

示例

# 定义列表
list = ["你好",12,"你好","我是小美","我是小昕"]
for item in list:print(item)

元组

元组的定义

• 元组和列表类似，区别在于列表是可修改的，元组定义之后 是不可修改的

# 定义元组
t1 = (1,"n奥",True)
# 定义空元组
t2 = ()
t3 = tuple()
print(f"t1的类型是{type(t1)}，内容是{t1}")
print(f"t2的类型是{type(t2)}，内容是{t2}")
print(f"t3的类型是{type(t3)}，内容是{t3}")
===========结果展示===============
t1的类型是<class 'tuple'>，内容是(1, 'n奥', True)
t2的类型是<class 'tuple'>，内容是()
t3的类型是<class 'tuple'>，内容是()

操作方法

方法	描述
tuple.index(元素)	查找元素所在元组中的索引
tuple.count(元素)	统计元组中某元素数量
len(tuple)	统计元组中全部元素数量

元组的特点

• 和list基本相同(有序、任意数量元素、允许重复元素)，唯一不同在于不可修改。
• 可以修改内部list的内部元素
• 支持for循环

# 定义元组
t1 = (1,"n奥",True,[12,23,2])
# 尝试修改元组
t1[1] = "瞧瞧"
print(t1)
# 修改失败 程序出现异常 TypeError: 'tuple' object does not support item assignment
# 修改元组中的列表
t1[3][2] = "你好"
print(t1)
# 修改成功：(1, 'n奥', True, [12, 23, '你好'])

字符串

• 尽管字符串看起来并不像:列表、元组那样，一看就是存放了许多数据的容器但不可否认的是，字符串同样也是数据容器的一员。
• 字符串是字符的容器，一个字符串可以存放任意数量的字符。

常用操作

方法	描述
str.index(字符)	查找字符所在字符串中第一个字符的索引
str.count(字符)	统计字符串中某字符数量
len(str)	统计字符串中全部字符数量
str.replace(字符1，字符2)	将字符串中全部的字符1替换成字符2
str.strip()	去除字符串前后的空格
str.strip(字符)	去除字符串头部和尾部的指定字符
str.split(字符)	根据字符将字符串切分为list列表

text = "你好，我好，大家好，我是王小美。"
print(text)
# 尝试修改 字符串，结果异常了，字符串和元组一样是不可修改的
# text[8] = "丑"
# 统计字符串中全部字符数量  16
l = len(text)
print(l)
# 统计字符串中某字符数量  3
c = text.count("好")
print(c)
# 查找字符所在字符串中第一个字符的索引 1
i=text.index("我")
print(i)# 将字符串中全部的字符1替换成字符2，不会改变原有的字符串，需要重新定义变量赋值
# 你帅，我帅，大家帅，我是王小美。
ret = text.replace("好","帅")
print(ret)# 去除字符串前后的空格   1q 我是1王小q美。 qq11
text = " 1q 我是1王小q美。 qq11 "
result = text.strip()
print(result)
# 去除字符串前后的1和q   我是1王小q美。 
text ="1q 我是1王小q美。 qq11"
rest = text.strip("1q")
print(rest)# 根据字符将字符串切分为list列表 result的的结果是['你好', '我好', '大家好', '我是王小美。'],类型是<class 'list'>
text = "你好，我好，大家好，我是王小美。"
result = text.split("，")
print(f"result的的结果是{result},类型是{type(result)}")

序列切片

语法:序列[起始下标:结束下标:步长]

表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列

1. 起始下标表示从何处开始，可以留空，留空视作从头开始
2. 结束下标(不含)表示何处结束，可以留空，留空视作截取到结尾
3. 步长表示，依次取元素的间隔

• 步长1表示，一个个取元素
• 步长2表示，每次跳过1个元素取
• 步长N表示，每次跳过N-1个元素取
• 步长为负数表示，反向取(注意，起始下标和结束下标也要反向标

# 对list进行切片，从1开始，4结束，步长1     [2, 3, 4]
list = [1, 2, 3, 4, 5]
result = list[1:4:]
print(result)
# 对tuple进行切片，从头开始，到最后结束，步长1   (1, 2, 3, 4, 5)
tuple = (1, 2, 3, 4, 5)
result = tuple[::]
print(result)
# 对str进行切片，从头开始，到最后结束，步长2   acegikmo
str = "abcdefghijklmnop"
result = str[::2]
print(result)
# 对str进行切片，从头开始，到最后结束，步长-1   ponmlkjihgfedcba
str = "abcdefghijklmnop"
result = str[::-1]
print(result)
# 对列表进行切片，从3开始，到1结束，步长-1  [4, 3]
list = [1, 2, 3, 4, 5]
result = list[3:1:-1]
print(result)
# 对元组进行切片，从头开始，到尾结束，步长-2  (5, 3, 1)
tuple = (1, 2, 3, 4, 5)
result = tuple[::-2]
print(result)

set集合

• 基础语法{元素,元素,元素,}
• 集合是无序且不重复的
• 因为无序不支持下标访问
• 可修改

set = {"你好","你好","我好","帅","是吧","是吧"}
print(f"集合的内容{set},集合的类型{type(set)}")输出
集合的内容{'我好', '你好', '是吧', '帅'},集合的类型<class 'set'>

常用操作

set = {"你好","你好","我好","帅","是吧","是吧"}
print(f"集合的内容{set},集合的类型{type(set)}")
# 添加新元素  {'帅', '我是新来的', '你好', '我好', '是吧'}
set.add("我是新来的")
print(set)
# 移除元素   {'帅', '我是新来的', '我好', '是吧'}
set.remove("你好")
print(set)
# 随机取出一个元素   帅
res = set.pop()
print(res)
# 清空集合   set()
set.clear()
print(set)set1 = {1,2,3,4,5}
set2 = {1,2}
# 取2个集合的差集 集合1和集合2不变  {1, 2}
result = set1.difference(set2)
print(result)
print(set1)
# 消除2个集合的差集
set1.difference_update(set2)
print(set1)  # {3, 4, 5}
print(set2) # {1, 2}# 2个集合合并为1个  {1, 2, 3, 4, 5, 65}
set1 = {1,2,3,4,5}
set2 = {3,4,65}
set3 =set1.union(set2)
print(set3)
# 统计集合元素数量
l = len(set3)
print(l)
# 集合的遍历
for item in set3:print(item)