迁移到飞书
知识点
.join()
分割符.join(列表）:用分隔符将列表各个元素串联.join(['a','b','c','d'])——》abcd
random.sample()
生成指定数量的随机字符，返回列表 random.sample('abcd',2)——》[b,d]
random.shuffle()
将列表打乱顺序random.shuffle(['a','b','c','d'])——》['d','c','a','b']
shuffle会直接修改原始列表，而不会创建一个新列表
random.choice()
随机返回序列中的一个元素random.choice(['red','blue','green'])——》green
list.index(元素)
查询列表元素的索引
待学习
readlines()
将文件中所有行作为列表返回，其中每一行都是列表对象
readline()
replace()
字符串替换方法
strip()
items()
高阶函数
接受函数为参数，或者能把函数作为结果返回的函数是高阶函数
高级函数参数
- 关键词参数
def my_func(a,b,c):
# do this with a
# then do this with b
# finally do this with c
my_func(a=1,b=2,c=3)
调用函数时，用参数提供数值【任何顺序】
- 默认函数参数【为可选参数提供默认值】
def my_func(a=1,b=2,c=3):
# do this with a
# then do this with b
# finally do this with c
调用函数,my_func()不用输入参数就能正常调用。
如果想修改参数，改成自定义，my_func(b=5)即可
- 函数接受任意数量的位置参数【使用*args】
def add(n1,n2):
return n1+n2
若要增加参数，
def add(*args):
for n in args:
print(n)
进入函数，可遍历所有参数，该参数是一个元祖的形式。
[args]无限位置参数，非必须，传递给函数的参数的位置
[*]这个星号才是必须，最重要的，它告诉python add函数可以接受任意数量的参数
def add(*args):
sum = 0
for n in args:
sum += n
return sum
add(1,2,3,4)
还可以通过索引访问print(args[2])
- 任意数量的关键字参数【使用双星号运算符】
def cal(**kwargs):
for key, value in kwargs.items():
print(key)
print(value)
cal(add=1,jian=2)
[kwargs] 关键字参数
[**]告诉python接收任意数量的参数
同样它也可以通过索引访问
print(kwargs["add"]
假设传入一个正常的位置参数
def cal(n,**kwargs):
n += kwargs["add"]
n *= kwargs['cheng']
print(n)
cal(2,add=3,cheng=2)
(2+3)*2=10
实际创建多个可选关键字的类
class Car:
def _init_(self,**kw):
self.make = kw.get("make")
self.model = kw["model"]
注意：kw.get()和kw[]的区别在于，如果关键词错误，get()会返回none而不会报错
mycar = Car(make="nissan",model="GT-R")
print(mycar)
oop 类&对象
pycharm和colob安装包
通过包的类来创建对象 class——》object
使用对象object的方法(method)来使用:object.method() ——》相当于使用类的函数
使用对象的属性(attribute)来修改或...:object.attribute ——》相当于使用类的属性值
对象属性
属性：是对象拥有的东西，且与最终结果相关的变量。
举例：
class User:
pass
user_1=User()
user_1.id="01"
user_1.name="jack"
通过User创建了一个对象user,并给对象指定了两个属性，id和name，属性值为01和jack
对象方法【methods】
方法：是对象能干什么的功能,与特定对象相关联的函数。当函数与对象绑定的时称为方法。
语法与函数不一样：
class Car:
...
def stop():
...
car=Car()
car.stop()
利用汽车对象,通过. 调用car对象相关联的stop()函数
构造函数【初始化】【属性】
从类中创建我的对象时，如何指定所有的起始信息？【通过构造函数】
当对象被构造时，在编程中也叫做初始化。
初始化对象时，可以将变量设置为它们的起始值。
在python中，创建构造函数的方式是使用一个特殊的函数。
初始化函数：
class 类名:
def __init__(self):
initiallise attributes 初始化属性值
###这里写想要干什么
名字两边的下划线表示它是python解释器知道的一种方法，并且有一个特殊功能【初始化属性的功能】
例如：
class User:
def __init__(self):
print("每次创建新对象时，会触发这个")
user_2= User()
运行的结果就是在创建新对象user_2时会打印这条语句。
再比如：
class Car:
def __init__(self,seats):
self.seats=seats
my_car = Car(5)
init函数和init函数内部，self是正在创建或初始化的实际对象【my_car】。
还可以根据需要添加任意数量的参数。
当一个对象被创建时，类()里【这里的Car】所带的参数，一旦有参数，即使用参数来设置对象的属性。
举例:
my_car = Car(5)
通过调用类名来创建对象。
如果在init函数中，有额外的参数,也可将数据传递给那些参数，将用于设置该对象的属性。
my_car = Car(5) 那这条代码实际上就是my_car.seats=5。
这与我们自己设置的my_car=Car(),my_car.seats=5是一样的。
当创建很多对象时，需要所有相同的属性，如何搞定。如果想传递用户id,就将其添加为参数，
class User:
def __init__(self，user_id):
self.id=user.id
self.id成为与User类关联的属性，将其设置成等于任何用户获取时传入的user.id。
当创建用户时，即在类中添加user.id
user_1=User("01")
再增加一个属性
class User:
def __init__(self，user_id，username):
self.id=user.id
self.username=username
(user_id）参数
(user_id）这个参数值也等于self.id的属性
这些可以随意命名，通常约定是参数的名称=属性的名称，但不强制
user_1=User("01","jack")
上面这句创建了一个新用户，用("01","jack")这些值初始化它，其中第一个值是“01”=self.id
第二个值"jack"=self.username.
如果想打印user_1的用户名，print(user_1.username)
如果想打印user_1的id，print(user_1.id)
注意：上面的例子中，当向构造函数添加参数时，
当新对象是从这个创建时，必须提供user_id和username这2条数据。
构造函数【初始化】【方法】
class Car:
def enter_race_mode():
self.seats=2
mycar.enter_race_mode()
在类声明中，有一个函数【当函数附加到对象时,称为方法】
self.seats=2 所做的是获取对象及获取对象属性，将其改为2
所以调用该方法时，抓住对象，然后使用. 来调用：mycar.enter_race_mode()
栗子
class User:
def __init__(self,user_id,username):
self.user_id=id
self.username=username
self.guanzhu=0
self.fensi=0
def follow(self,user):
self.guanzhu += 1
user.fensi+= 1
user_1=User("01","jack")
user_2=User("02","pei")
user_1.follow(user_2)
print(user_1.guanzhu)
print(user_1.fensi)
print(user_2.guanzhu)
print(user_2.fensi)
数据类型
元组
python里的一种数据类型：如（1，3，5），有序的数据类型,
my=（1，3，5）
和list[1,3,5]有点类似，同样元组也可通过索引来访问，但元组不能更改数值，也不可删除。
切片
[]
列表&列表推导
num = [1,2,3]
num_list = []
for n in num:
add_1 = n+1
num_list.append(add_1)
将上面4行代码合二为一就是列表推导。
num_list = [n+1 for n in num]
列表推导：
new_list = [要做的事 for 列表的每一项 in 列表]
如果需要满足条件
列表推导
new_list = [要做的事 for 列表的每一项 in 列表 if 条件]
字典&字典推导
new_dict = {new_key:new_value for item in list}
注：list可以是任何可迭代的list,tuple,dict，range范围，字符串等
用现有字典的所有项目，用key和value创建新的key和新的value,来创建新字典
new_dict = {new_key:new_value for (key,value) in dict.items()}
用现有字典获取里面所有的项目，将其拆分为键和值，再循环遍历所有的每个键和每个值
添加条件
new_dict = {new_key:new_value for (key,value) in dict.items() if 条件 }
在控制台输入
names = ['anna','joe','john','tim','tom']
import random
新建一个字典，学生名随机生成分数的字典
student_score = {student:random.randint(1,100) for student in names}
遍历字典
新建考试合格的学生字典，用student_score生成一个新字典【score>=60】
passed_student = {student:score for (student,score) in student_score.items() if score >=60}
类
一个类创建多个实例
一个类创建多个实例，这些实例彼此之间是互相独立的
类继承
类继承：类继承其他类的方法和属性。
比如：正常的一个类
class Fish:
def __init__(self):
让这个类从另一个类继承，Animal是【想要继承的类】
class Fish(Animal):
def __init__(self):
super.__init__()
为了掌握动物类所拥有的一切，在初始化设置中添加super().__init__().
super指的是超类，初始化超类可以在鱼类中做所有事情
【理解就是继承类的所有属性和方法，父类的东西，子类全都有】
栗子：
class Animal:
def __init__(self):
self.eyss=2
def breathe(self):
print("hahaha")
class Fish(Animal):
def __init__(self):
super().__init__()
def swim(self):
nemo=Fish()
nemo.swim()
nemo.breathe()
#注释nemo.breathe()也能正常调用。
如果想继承方法，并让这个方法做其他的事：
class Fish(Animal):
def __init__(self):
super().__init__()
def breathe(self):
super().breathe()
print("do another something")
【这里的super().breathe()调用的就是父类的breathe方法】
nemo.breathe() 会调用父类的breathe方法和自己定义的breathe方法
文档读写
读&写
文件放在项目下，和运行文件同一层级
读
1.第一种方式
file = open("my_file.text)
contents= file.read()
print(contents)
file.close
2.第二种with关键字
with open("my_test.txt",encoding='utf-8') as f:
contents = f.read()
print(contents)
# with关键字直接管理文件,完成后会自动关闭
以中文格式打开
file = open("my_test.txt",encoding='utf-8')
写
替换文本
with open("my_test.txt",encoding='utf-8',mode='w') as f:
f.write("之前的文本会被直接替换成新文本。")
追加文本
with open("my_test.txt",encoding='utf-8',mode='a') as f:
f.write("\n 追加新文本")
【mode= w ——>> write】
【mode=a ——>>append】
若文件不存在会新建文件
文件路径和文件名
在window系统,根文件夹一般是c盘。
绝对路径：相对于根目录开始。
相对路径：相对于当前的工作目录。
./ 表示在当前文件夹中查找
../ 表示在结构层次中向上一步到父级
打开python_project下的test.txt
with open("/python_project/my_test.txt",encoding='utf-8') as f:
contents = f.read()
print(contents)
绝对路径
with open("/user/python_project/my_test.txt",encoding='utf-8') as f:
contents = f.read()
print(contents)
文本的相对路径
with open("../day24/my_file.txt",encoding='utf-8') as f:
contents = f.read()
print(contents)
mac路径是用/分割，而win是用\分割
csv
import csv
with open("226 weather-data.csv") as file:
data = csv.reader(file)
tem = []
for row in data:
if row[1] != "temp":
tem.append(row[1])
print(tem)
导入模块的多种方式
模块是一个包含Python定义和语句的文件，文件名是模块名加上.py后缀
包是一个包含模块的目录，该目录下必须包含一个名为__init__.py的文件
以turtle模块里的Turtle类为例：
第一种：
import turtle
//导入 模块名称
my_object = turtle.Turtle()
第二种
from turtle import Turtle
//从某模块中导入模块里的部分内容，推荐
第三种
from turtle import *
//从某模块中导入所有内容 尽量少用
第四种
from turtle as t
//给模块起别名
turtle模块是与python一起打包的标准库
如果是其他模块，要先安装
pandas模块
pandas文档读写
import pandas
data = pandas.read_csv("226 weather-data.csv")
print(data['temp'])
print(round(data['temp'].mean(),2))
# 求温度这列的平均值
print(data["temp"].max())
# 求温度这列的数值的最大值
获取某列的数值
print(data['condition'])
print(data.condition)
这2个打印的内容几乎一致，上面的[]相当于字典的键值对，下面的.更像把condition理解为属性
获取某行的数值
print(data[data.temp == data.temp.max()])
在dataframe[]，在[]里选择指定的列，就能获取一行的值。
获取某行指定列的数值
在获取某行的基础上，再给数据框具体的列
print(data[data.day == "Monday"].condition)
直接创建一个dataframe 数据框
例如，由这个字典创建一个dataframe：
data_dict ={"students":["amy","joe","tim"],"scores":[76,54,65]}
data = pandas.DataFrame(data_dict)
print(data)
数据框中使用循环、遍历
student_dict ={"students":['tom','tim','joe'],"score":[56,76,98]}
创建for循环遍历该字典：
for (key,value) in student_dict.items():
print(key)
导入pandas库
import pandas
student = pandas.DataFrame(student_dict)
print(student)
遍历数据框
for (key,value) in student.items():
print(value)
print(key)
注：该遍历并不有用
利用pandas的内置循环，iterrows()方法来遍历【循环遍历数据框的每一行】
for (index,row) in student.iterrows():
print(index)
print(row)
或者使用点获取特定列下的值：
print(row.student)
print(row.score)
或者加入if条件使用：
if row.student == 'tim':
print(row.score)
在数据框中使用字典推导式：
student_dict ={"name":['tom','tim','joe'],"score":[56,76,98],"age":[12,13,15],"year":[2000,2001,2003],"month":[3,4,5],
"day":[10,11,12]}
import pandas
student = pandas.DataFrame(student_dict)
test = {(student_row["name"],student_row["age"]):student_row for(index,student_row ) in student.iterrows()}
print(test)
输出的test格式：
{ ('tom', 12): name tom score 56 age 12 year 2000 month 3 day 10 Name: 0, dtype: object, ('tim', 13): name tim score 76 age 13 year 2001 month 4 day 11 Name: 1, dtype: object, ('joe', 15): name joe score 98 age 15 year 2003 month 5 day 12 Name: 2, dtype: object }
在上面的字典里，获取name或者age对应的值：
student_row = test[('tom', 12)]
name_value = student_row['name']
age_value = student_row['age']
test字典的键是由(name, age)元组组成的，使用test[('tom', 12)]获取整个学生行数据
由于该行数据是一个 Pandas 系列,可以使用索引作 student_row['name'] 和student_row['age']
分别获取name 和age的值。
pandas待学习方法
item()
title()
turtle模块
Screen类的监听事件:
from turtle import Screen
my_screen=Screen()
my_screen.listen()
#语法: my_screen.onkey(function,key)
正则
- import re 导入正则模块
- 本义字符 a-z A-Z 0-9
- 特殊字符： \ + * . ? - ^ $ | ( ) [ ] { } < >
Tkinter模块
- 创建GUI 图形用户界面
导入tkinter
import tkinter
window = tkinter.Tk()
window.title('GUI program')
window.minsize(300,300)
my_label = tkinter.Label(text="标签",font=('Arial',18,'bold'))
my_label.pack(side='left')
window.mainloop()
API
- 响应代码
1xx:等等
2xx:一切成功
3xx:go away 没有权限
4xx :you screwed up 搞砸/404
5xx :i screwed up 请求失败【服务器关闭，网站关闭或其他问题】
- API参数
