Python学习笔记

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

提示：这里可以添加本文要记录的大概内容：

Python笔记

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、列表的方法

1.列表.append(元素)

向列表中追加元素，不考虑元素位置

2.列表.extend（容器）

向列表中添加整个容器的内容

3.列表.insert(下标，元素)

向列表特定位置中插入特定元素

4.del.列表(下标)

删除列表中特定下标的元素

5.列表.pop(下标)

删除列表中特定下标的元素

6.列表.remove(元素)

删除指定元素

7.列表.clear()

清空列表

8.列表.count(元素)

统计列表中某元素的个数

9.列表.index(元素)

返回特定元素的下标

10.len.(列表)

返回列表的长度

小练习

ages = [21, 25, 21, 23, 22, 20]
new_list = [29, 33, 30]
ages.append(31) #追加31
print(ages)
ages.extend(new_list) #追加新列表元素
print(ages)
first = ages[0] #取出第一个元素
print(first)
last = ages[-1] #取出最后一个元素
print(last)
print(ages.index(31)) #返回元素31的下标

二、列表的遍历

1.while 循环

理论上可以无限循环

my_list= [1, 2, 3, 4, 5, 6]
index = 0
while index < len(my_list):
    num = my_list[index]
    print(my_list[index],end='')
    index += 1

2.for 循环

理论上不可以无限循环，但for循环更简单更常用

my_list= [1, 2, 3, 4, 5, 6]
len = len(my_list)
for i in range(len):
    num = my_list[i]
    print(my_list[i],end='')

上面的麻烦了

my_list= [1, 2, 3, 4, 5, 6]
for i in my_list:
    print(f"{i}",end='')

小练习

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
new_list = []
# for i in my_list: #for循环实现
#     if i % 2 == 0:
#         new_list.append(i)
# print(new_list)
i = 0
while i < len(my_list): #while循环实现
    if my_list[i] % 2 == 0:
        new_list.append(my_list[i])
    i += 1
print(new_list)

三、元组

t1 = (1, “hello”, True)
t2 = ()
t3 = tuple()
如果只有单个元素，元素后要加“,”逗号。
t4 = (“hello”, )
元组只读不可修改，但元组内若嵌入了列表，则可以修改列表内的元素

1.元组嵌套

t5 = ((1, 2, 3),(4, 5, 6))

2.取出元组内容

num = t5[1][2] print(num)–> 6
支持下标索引，与list相同

3.各种方法与list相同

元组.index()
元组.count()
len(元组)

4.元组遍历

for while

小练习

yuanzu = ('周杰伦', 11, ['football', 'music'])
age_index = yuanzu.index(11)
print(age_index) #查询年龄下标
print(f"姓名为{yuanzu[0]}")
yuanzu_del = yuanzu[2].pop(0)
print(yuanzu)
yuanzu = list(yuanzu)
print(type(yuanzu))
yuanzu_1 = yuanzu[2].append('coding')
yuanzu_1 = tuple(yuanzu)
print(yuanzu_1)

四、字符串

只读，不能修改内容

1.取值

my_str = “123 456 789”
value = my_str[2]
print(value)—>3

2.方法

1.index

字符串.index(“查找值”)
返回查找值的首地址

2.replace（“被替换内容”，“替换内容”）

替换字符串

my_str = "123 456 789"
new_str = my_str.replace('123', '321')
print(new_str)

结果得到321 456 789

3.str.split()

字符串分割
按照指定的分割符字符串，将字符串划分多个字符串并保存在列表对象中。字符串本身不变，得到了一个列表对象。

my_str = "123 456 789"
# new_str = my_str.replace('123', '321')
new_list = my_str.split(' ')
print(new_list)
得到列表内容为['123', '456', '789']

4.字符串规整str.strip()

不传参数，默认删除字符串中前后的空格

my_str = "  123 456 789  "
# new_str = my_str.replace('123', '321')
new_str = my_str.strip()
print(new_str)
得到前后没空格的123 456 789

传入参数，则删除传入的字符小子串

my_str = "23 456 321"
# new_str = my_str.replace('123', '321')
new_str = my_str.strip('12') #传入的串“12”可以看为两个小子串1和2 
print(new_str)
得到3 456 3

5.统计字符串中元素出现的次数str.count(元素)

6.统计字符串长度len(str)

常用操作

小练习

my_str = "itheima itcast boxuegu"
num_it = my_str.count('it') #统计it个数
print(num_it)
new_str = my_str.replace(" ","|") # |替换空格
print(new_str)
new_list = new_str.split("|") #按|分类，得到新列表
print(new_list)

五、序列

1.切片：从一个序列中取出一个子序列。（从一个大序列中取一个小序列）。

1.1.语法： 序列（起始下标：结束下表：步长）

小练习

my_str = "万过薪月，员序程马黑来，nohtyp学"
new_str = my_str[9:4:-1]
print(new_str)

my_str = "万过薪月,员序程马黑来,nohtyp学"
one_str = my_str.split(",")[1].replace("来", "")
print(one_str[::-1])

六、集合

不允许重复，顺序不保证，不支持下标访问，允许修改

1.add方法

集合.add(“xxx”)添加元素
会自动去重，如果添加的元素原本就有则添加没效果

2.remove方法

集合.remove(“xxxx”) 删除xxxx元素

3.pop随机取数

集合.pop()，没有参数 ，随机取出，需要有变量接收取出的结果，去除之后原集合中就不再有该元素

4.clear()清空集合

集合.clear(),返回空集合ser()

5.取出两个集合的差集

集合1.difference(集合2)

set1 = {1, 2, 3, 6}
set2 = {1, 2, 3, 4, 5}
set3 = set1.difference(set2)
print(set3)
{6}

6.消除两个集合的差集

集合1.deffrence_updata(集合2)
在集合1内删除和集合2相同的元素，集合2不变

set1 = {1, 2, 3, 6, 7}
set2 = {1, 2, 3, 4, 5}
set3 = set1.difference_update(set2)
print(set1)
{6, 7}

7.union合并集合

集合1.union(集合2）得到新集合，不修改已有集合，得到新集合，实际就是两个集合的并集。没有重复元素。

8.统计集合元素数量len()

集合.len()

总结

传参方式

位置参数：根据函数定义的参数位置来传递参数

def user_info(name,age,gender):
    print(f'名字{name}，姓名{age}，性别{gender}')
user_info('小明',18,'男')

关键字参数:指定形参传递参数

def user_info(name,age,gender):
    print(f'名字{name}，姓名{age}，性别{gender}')
user_info(name = '小米',age = 15,gender='女')

两种方式可以混用
缺省参数：也叫默认参数，定义函数时规定的值。若调用方法时没有传入特定参数则使用默认参数，传入新的参数会修改默认参数。缺省参数必须在最后

def user_info(name,age,gender = '男'):
    print(f'名字{name}，姓名{age}，性别{gender}')
user_info(name = '小米',age = 15)

不定长参数：*args **kwargs

匿名函数

将函数作为参数传递
lambda匿名函数，只能临时使用一次
lambda 传入参数:函数体

def test_func(compute):
    result = compute(1,2)
    print(result)
# def compute(x,y):
#     return x+y
# test_func(compute)
test_func(lambda x,y:x+y)

八、文件读取

1.open()

open(name,mode,encoding)
name:文件名
Mode:打开模式（只读r，写入w，追加a）
encoding：编码格式 （utf-8）
f = open(‘python.txt’,‘r’,encoding = ‘utf-8’)
f.readlines()读取全部行
f.readline()一次读一行

2.with open() as f

读取完自动关闭文件

*浏览器卡退了
**少一部分函数调用的内容

自定义模块引用

if name == ‘main’
可以引入该模块，但不执行模块内的函数调用

类的定义和使用

class 类名:
类的属性 类中的变量（成员变量）
类的行为 类中的函数（成员方法）
创建类对象的语法
对象 = 类名（）
类内部的函数—》方法
def 方法名(self,形参1，形参2…)传参时可以忽略self

类：设计图纸 对象：生产的实体 面向对象的编程：使用对象进行编程