Python学习3

合集 - Python学习(7)

1.Python学习22023-11-12

2.Python学习32023-12-04

3.Python学习42023-12-064.Python学习52023-12-115.Python学习62023-12-176.Python学习72023-12-197.Python学习12023-11-07

收起

函数：

函数是组织好的、可重复使用的、用来实现特定功能的代码段

作用：  ①将功能封装在函数内，可供随时随地重复利用   ②提高代码的复用性，减少重复代码，提高开发效率

str1="138328378"
str2="27384"
str3="7987340"

def my_len(data):  #注意这里必须有冒号！！！
    count = 0
    for i in data:
        count += 1
    print(f"字符串{data}的长度为{count}")

my_len(str1)
my_len(str2)
my_len(str3)

函数的定义：

def 函数名（传入参数）：

　　函数体

　　return 返回值

 函数的使用步骤：  ①先定义函数   ②后调用函数

注意：  ①参数不需要，可以省略   ②返回值不需要，可以省略

 函数的传入参数的作用是： 在函数运行的时候，接受外部传入的数据

def add(x,y):
    result=x + y
    print(f"{x} + {y}的计算结果是：{result}")

#调用函数
add(5,6)

• 函数定义中，提供x和y，称之为： 形式参数（形参），表示函数声明将要使用2个参数    参数之间使用逗号进行分隔
• 函数调用中，提供的5和6，称之为实际参数（实参），表示函数执行是真正使用的参数值    传入的时候，按照顺序传入数据，要和形式参数一一对应，使用逗号分隔

return返回：

 通过return关键字，就能向调用者返回数据      函数体在遇到return后就结束了，所以写在return后的代码不会执行！

示例：

def add(a,b):
    result = a + b
    return result

r=add(1,2)
print(r)

定义两束相加的函数功能。功能完成后，就会将相加的结果返回给函数调用者，所以，变量r接收到了函数的执行结果。

None类型

如果函数没有使用return语句返回数据，函数其实也是有返回值的。Python中有一个特殊的字面量，类型是<class 'NoneType'>

无返回值的函数，实际上就是返回了None这个字面量

None表示： 空的、无实际意义的

使用场景：

①用在函数无返回上

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

③用于声明无内容的变量上：定义变量，但暂时不需要变量具有具体值，可以用None来代替

#None用于if判断：
def check_age(age):
    if age > 18:
        return "SUCCESS"
    else:
        return None

result = check_age(16)
if not result:
    #进入if表示result是None值，也就是False
    print("未成年！不可进入！")

函数文档：

 param:用于解释参数            return：用于解释返回值

通过给函数添加说明文档，可以辅助理解函数的作用，  通过多行注释的形式，对函数进行解释说明。  内容应该写在函数体之前

在PyCharm编写代码时，可以通过鼠标悬停，查看调用函数的说明文档

 函数嵌套：

函数A中执行到调用函数B的语句，会将函数B全部执行完成后，继续执行函数A的剩余内容

def func_b():
    print("------2------")

def func_a():
    print("------1------")
    func_b()
    print("------3------")

#调用函数func_a
func_a()

变量的作用域指的是变量的作用范围（变量在哪里可用，在哪里不可用）主要分为两类： 局部变量和全局变量

局部变量：  作用范围在函数内部，在函数外部无法使用

def test_A():
    num =100
    print(num)
test_A()    # 100
print(num)  # 报错：name 'num' is not defined

变量a是定义在 'testA' 函数内部的变量，在函数外部访问则立即报错

全局变量：作用在函数内和函数外部均可   可使用global关键字，将函数定义的变量声明为全局变量

num = 100 #全局变量
def test_A():
    print(num)

def test_B():
    num = 200
    print(num)

test_A()                 #结果：100
test_B()                 #结果：200
print(f"全局变量num= {num}")    #结果：全局变量num = 100

可以发现在 'test_B' 函数中的num变量是一个函数中的局部变量，并没有改变全局变量num的值

可以使用global关键字，将函数内部声明变量为全局变量，示例：

num = 100 #全局变量
def test_A():
    print(num)

def test_B():
    #global 关键字声明a是全局变量
    global num
    num = 200
    print(num)

test_A()                 #结果：100
test_B()                 #结果：200
print(f"全局变量num= {num}")    #结果：全局变量num = 200

容器：

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

数据容器根据特点的不同，如：是否支持重复元素；是否可以修改；是否有序等等  可以分为五类：

列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）   它们各有特点，但都满足可容纳多个元素的特性

 列表（list）：

变量名称=[ 元素1 ，元素2 ， 元素3， 元素4，······ ]

#定义空列表：

变量名称= [  ]

变量名称= list ( )

列表内的每一个数据，称之为元素，   以 [  ] 作为标识；   列表内的每一个元素之间，用逗号隔开

注意：  列表可以一次存储很多数据，且！可以为不同类型的数据类型，支持嵌套。

my_list = [[1,2,3],[4,5,6]]
print(my_list)
print(type(my_list))

 索引：

我们可以使用下标索引取出列表的特定位置的数据。 列表中的每个元素都有其下标索引

从前向后的方向，从0开始，依次递增：

 或者，可以反向索引，也就是从后向前：从-1开始，依次递减（-1，-2，-3······）

 如果列表是嵌套的列表，同样也支持下标索引：

# 取出嵌套列表的元素
my_list=[[1,2,3],[4,5,6]]
print(my_list[1][2])     #元素：6

注意：  下标索引的取值范围，超出范围则无法取出元素，并且会报错

函数与方法

函数是一个封装的代码单元，可以提供特定功能。 在python中，如果将函数定义为class（类）的成员，那么函数会称之为：方法

方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同：

函数的使用：   num=add(1,2)

方法的使用： student =Student ( )

                       num= student.add(1,2)

导入一个int型的列表：

my_list = [int(i) for i in input().split()]
print(max(my_list))
print(min(my_list))

列表的查询：

功能：查找指定元素在列表的下标，如果找不到，报错 ValueError

语法：列表.index(元素)               index就是列表对象（变量）内置的方法（函数）

#  查找某元素在列表内的下标索引：
my_list=["你好","今天","开心","再见","！！！"]
index=my_list.index("再见")
print(f"再见在列表中的下标索引值是:{index}")

列表的修改：

功能：修改特定位置（索引）的元素值，  可以对指定下标（正向、反向下标均可）的值进行重新赋值

语法：列表 [下标] = 值 

#  修改特定下标索引的值：
my_list=["你好","今天","开心","再见","！！！"]
my_list[0] = "天晴"
print(f"列表被修改元素值后，结果是：{my_list}")

列表的插入：

功能：在指定的下标位置，插入指定元素

语法：列表.insert（下标，元素）

#  在指定下标位置插入新元素：
my_list=["你好","今天","开心","再见","！！！"]
my_list.insert(1,"我")
print(f"列表插入人元素值后，结果是：{my_list}")

列表的追加1：

功能：将指定元素，追加到列表的尾部

语法：列表.append（元素）

#  在列表的尾部追加 单个！ 新元素：
my_list=["你好","今天","开心","再见","！！！"]
my_list.append("下次见！")
print(f"列表在追加元素后，结果是：{my_list}")

列表的追加2：

功能：将其他数据容器的内容取出，依次追加到列表尾部

语法：列表.extend（其他数据容器）

#  在列表的尾部追加 一批！ 新元素：
my_list=["你好","今天","开心","再见","！！！"]
my_list2=[111,1111,11111]
my_list.extend(my_list2)
print(f"列表在追加一个新列表后，结果是：{my_list}")

列表的删除1：

功能：删除特定位置（索引）的元素值

语法1：del 列表 [下标]       语法2：列表.pop（下标）

#  列表元素的删除操作
#  方式一   del 列表[下标]
my_list = ["你好","今天","开心","再见","！！！"]
del my_list[2]
print(f"列表删除元素后，结果是：{my_list}")
#  方式二   列表2.pop(下标)
element = my_list.pop(1)
print(f"通过pop方法取出元素后列表内容：{my_list},取出的元素是：{element}")

列表的删除2：

功能：删除某元素在列表的第一个匹配项

语法：列表.remove（元素）

#  删除某元素在列表中的第一个匹配项：
my_list = ["你好","今天","开心","再见","！！！"]
my_list.remove("开心")
print(f"列表通过remove移除元素后，结果是：{my_list}")

列表的清空：

语法：列表.clear ( )

#  清空列表：
my_list = ["你好","今天","开心","再见","！！！"]
my_list.clear()
print(f"列表被清空后，结果是：{my_list}")

列表的统计：

功能：统计某元素在列表内的数量

语法：列表.count（元素）

#  统计列表内元素的数量：
my_list = ["开心","你好","今天","开心","再见","！！！"]
count=my_list.count("开心")
print(f"列表中开心的数量是：{count}")

列表的长度：

功能：统计列表内，有多少元素      可以得到一个int数字，表示列表内的元素数量

语法：len (列表)

#  统计列表内全部元素的数量：
my_list = ["你好","今天","开心","再见","！！！"]
count=len(my_list)
print(f"列表中元素数量总共有：{count}个")

 列表的特点：

• 可以容纳多个元素（上限为2**63-1）
• 可以容纳不同类型的元素
• 数据是有序存储的（有下标序号）
• 允许重读数据存在
• 可以修改（删除或增加元素等）

列表的反转

使用方法： 列表名.reverse( )

该方法没有返回值，将列表中的所有元素进行原地排序

# reverse( )方法
a = [1, 2, 8, 4, 5]
a.reverse()
print(a)        # 结果： [5, 4, 8, 2, 1]

内置：reversed( )函数

语法：reversed(列表名)

与reverse( )方法不同，内置函数reversed( )不对原列表做出任何修改，而是返回一个逆序排序后的迭代对象

# reversed( )方法
a = [1, 2, 8, 4, 5]
a_1 = reversed(a)
print(a_1)              # 结果：<list_reverseiterator object at 0x00000253B144A460>
print(list(a_1))        # 结果：[5, 4, 8, 2, 1]

列表的排序

使用方法： 列表.sort(key=选择排序依据的函数，reverse=True|False)

参数key，是要传入一个函数，表示将列表的每一个元素都传入函数中，返回排序的依据

参数reverse，是否反转排序结果，True表示降序，False表示升序

# 如下嵌套列表，要求对外层列表进行排序，排序的依据是内层列表的第二个元素数字
my_list = [["a", 33], ["b",55], ["c", 11]]

# 定义排序方法
def choose_sort_key(element):
    return element[1]    # 按照第二个元素进行排序

my_list.sort(key=choose_sort_key,reverse=True)    # 将元素传入choose_sort_key函数中，用来确定按照谁来排序
print(my_list)    # 结果是：[['b', 55], ['a', 33], ['c', 11]]

迭代、遍历：

既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。  将容器内的元素依次取出进行处理的行为成为：遍历、迭代

循环的条件为：下标值 < 列表的元素数量　　　　　　可以通过while或者for循环实现

while循环：

my_list = [21,25,21,23,22,20]
index = 0
while index < len(my_list):
    element = my_list[index]
    print(f"列表的第{index+1}个元素是:{element}")
    index += 1

for循环：　　　for循环更加适合对列表等数据容器进行遍历

 表示，从容器内，依次取出元素并赋值到临时变量上。在每一次的循环中，我们可对临时变量（元素）进行处理。

my_list = [21,25,21,23,22,20]
for element in my_list:
    print(f"列表的元素有：{element}")

while循环和for循环，都是循环语句，但细节不同：

• 在循环控制上：

　　　　　　while循环可以自定义循环条件，并自行控制

　　　　　　for循环不可以自定义循环条件，只可以一个个从容器内取出数据

• 在无限循环上：

　　　　　　while循环可以通过条件控制做到无限循环

　　　　　　for循环理论上不可以，因为被遍历的容器容量不是无限的

• 在使用场景上：

　　　　　　while循环适用于任何想要循环的场景

　　　　　　for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

 练习：

import math
list = [1,2,3,4,5,6,7,8,9,10]
list_new = []
for x in list:
    if x%2 == 0:
        list_new.append(x)
print(f"通过for循环，从列表：{list}中取出偶数，组成新列表{list_new}")
index = 0
list_new2 = []
while index < len(list):
    if list[index]%2 == 0:
        list_new2.append(list[index])
    index += 1
print(f"通过while循环，从列表{list}中取出偶数，组成列表{list_new2}")

元组

定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型

注意： 元组同列表一样（有序、任意数量元素、允许重复元素），都是可以封装多个、不同类型的元素在内。  但最大的不同点在于：元组一旦完成定义，就不可以修改。

#定义元组字面量

（元素，元素，元素，...... ，元素）

变量名称 = （元素，元素， ......，元素）

# 定义空元组

变量名称 = （ ）

变量名称 = tuple( )

#定义一个元组：
tup=(1,2,3,["hello","morning"])
print(f"tup的内容是{tup}")
tup[3][0]="你好！"
tup[3][1]="早上好！"
print(f"tup的内容是:{tup}")

定义只有一个元素的元组：  这个数据后面一定要添加逗号

#定义一个元素的元组：
tup = ('hello',)    #后面一定要加一个逗号

元组的基本操作

index ( ) 查找某个数据，如果数据存在返回对应的下标，否则报错

# 元组的操作: index查找方法
tup = ("今天","天气","很不错")
index = tup.index("天气")
print(f"在元组tup中查找天气，的下标是：{index}")

count ( ) 统计某个数据在当前元组出现的次数：

# 元组的操作: count统计方法
tup =("你好","天气","很好呀","很好呀","很好呀")
num = tup.count("很好呀")
print(f"在元组tup中统计很好呀的数量有：{num}个")

len ( ) 统计元组内的元素个数：

# 元组的操作: len函数统计元组元素数量
tup =("你好","天气","很好呀","很好呀","很好呀")
num = len(tup)
print(f"tup元组中的元素个数有{num}个")

元组的遍历：

tup=("你好！","今天","很不错！","yes")
# while遍历：
index = 0
while index < len(tup):
    print(f"元组的元素有：{tup[index]}")
    # 特别注意：
    index += 1

# for遍历：
for element in tup:
    print(f"元组的元素有{element}")

特别注意：  元组的元素不能修改，但是！可以修改元组内的list的内容（修改元素、增加、删除、反转等）

# 尝试修改元组内容
tup = (1,2,3,['你好！','很好呀'])
tup[3][1] = 'best'
print(tup)  # 结果：(1,2,3,['你好','best'])

练习：

tup = ('周杰伦',11,['football','music'])
index = tup.index(11)
name = tup[0]
print(f"他的姓名是{name}")
del tup[2][0]             # 注意元组中列表的删除
tup[2].append("coding")   # 注意元组中的列表的增加
print(tup)

字符串

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

字符串的特点： 只可以存储字符串； 不可以修改（增加或删除元素等）；长度任意； 支持下标索引； 运行重复字符串存在； 支持for循环 

字符串是字符的容器，一个字符可以存放任意数量的字符，如字符串“itheima”

 字符串的下标（索引）：

和其它容器如：列表、元组一样，字符串也可以通过下标进行访问

从前向后：下标从0开始；   从后向前：下标从-1开始

# 通过下标获取特定的位置字符：
my_str = "today is guud day"
# 通过下标索引取值：
value = my_str[2]
value2 = my_str[-8]
print(f"从字符串{my_str}取下表为2的元素，值是：{value},取下标为-8的元素，值是：{value2}")

同元组一样，字符串是一个：无法修改的数据容器

所以：修改、删除、追加字符等操作，均无法完成

查找特定字符串的下标索引：

语法：字符串.index（字符串）

my_str = "today is a guud day!"
# index方法：
value = my_str.index("guud")
print(f"在字符串{my_str}中查找guud，其起始下标是:{value}")

字符串的替换：

语法：字符串.replace(字符串1，字符串2)

功能：将字符串内的全部：字符串1，替换为字符串2

注意：不是修改字符串本身，而是得到了一个新的字符串哦！

my_str = "today is a guud day!"
# replace方法：
new_my_str = my_str.replace("guud","nice")
print(f"将字符串{my_str},进行替换后得到:{new_my_str}")

字符串的分割：

语法：字符串.split(分隔符字符串）

功能：按照指定的分隔字符串，将字符串划分为多个字符串，并存入列表对象中

注意：字符串本身不变，而是得到了一个列表对象

my_str = "today is a guud day!"
# split方法：
my_str_list = my_str.split(" ")
print(f"将字符串{my_str}进行split分割后得到：{my_str_list},类型是{type(my_str_list)}")

字符串的规整操作(前后去空格)：

语法：字符串.strip( )

my_str = "  today is a guud day!  "
# strip方法：
print(f"将字符串{my_str}前后去空格后为{my_str.strip()}")

字符串的规整操作（去前后指定字符串）

语法：字符串.strip(字符串)

my_str = "12today is a guud day!21"
# strip方法：
print(my_str.strip("12"))   # 结果：today is a guud day!

注意： 传入的是“12” 其实就是：“1” 和 “2” 都会移除，是按照单个字符！

 count统计和len统计

my_str = "today is a guud day! actually guud!"
# 统计字符串中某字符串的出现次数：count
count = my_str.count("guud")
print(f"字符串{my_str}中guud出现的次数是：{count}")
# 统计字符串的长度len
num = len(my_str)
print(f"字符串{my_str}的长度是：{num}")

join()语法

Str.join(sequence)

sequence——序列，可以是列表、元组、字符串、字典、集合等

# 连接列表
list1 = ['a', 'b', 'c']
Str = "".join(list1)
print(Str)          # 结果：abc

# 空格分隔
list1 = ['a', 'b', 'c']
Str = " ".join(list1)
print(Str)          # 结果：a b c

# "-"输出
list1 = ['a', 'b', 'c']
Str = "-".join(list1)
print(Str)          # 结果：a-b-c

字符串循环遍历：

my_str = "today is a guud day! actually guud!"
# while遍历：
index = 0
while index < len(my_str):
    print((my_str[index]))
    index += 1
print(" ")
for i in my_str:
    print(i)

 序列

序列是指：内容连续、有序，可以使用下标索引的一类数据容器。列表、元组、字符串均可以视为序列。

序列支持切片，即：列表、元组、字符串，均支持进行切片操作

 

 

切片：从一个序列中，取出一个子序列

语法：序列 【起始下标：结束下标：步长】   （注意：结束下标不包括在内）

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

• 起始下标表示从何处开始，可以留空，留空视作从头开始
• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
• 步长表示，依次取元素的间隔

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

注意：此操作不会影响序列本身，而是会得到一个新的序列！！

# 对list进行切片，从1开始，
my_list = [0,1,2,3,4,5,6]
result1 = my_list[1:4]      # 步长默认是1，所以可以省略不写
print(f"结果1：{result1}")

# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0,1,2,3,4,5,6)
result2 = my_tuple[:]       # 起始和结束不写代表从头到尾，步长为1可以省略不写
print(f"结果2：{result2}")

# 对str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{result3}")

# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1]
print(f"结果4：{result4}")

# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0,1,2,3,4,5,6]
result5 = my_list[3:1:-1]      # 反向切片要从大的开始到小的结束
print(f"结果5：{result5}")