python笔记

第一天

一.环境准备

​ python运行环境：真正执行代码运行的环境，安装（把当前安装的路径加到环境变量里）
​ 验证：就是Cmd输入python出现python版本信息
​ pycharm：运行代码的环境，他只是GUI工具，便捷的写代码的功能，然而真正运行python Interpreter，配置你本地的python Interpreter到pycharm上。
​ 新建项目：调整你自己放置的项目的路径
​ 记得查看你本地Existing Environment是否是你安装的python interpreter

二.数据类型

1.概念：整型：int 1,2,3,4,5…整数(正整数和负整数，以及0)
浮点型：float float 1.1, 1.2,3.3 小数(正小数，负小数) 0.0
布尔型：bool True or False
字节：bytes
字符：char
字符串：str（序列）
列表：list（序列）
字典：dic
元组：tuple（序列）
集合：set（序列）
空类型：None
复数：complex（a+bj）
空类型：None
复杂数据类型：tuple，list，dict
2.序列：不是python里的数据类型，序列是组织数据的一种类型,存储的时候，他的下标是从零开始的，访问的时候要通过下标去访问。
**那些不可变数据类型：**基础数据类型，元组
元组可变吗？不可变，真的不可变？
3.复杂数据类型:
元组：tuple_data = (元素1，元素2，元素3)
列表：list_data = [元素1，元素2，元素3]
字典：dict_data = {key:value, key:value, key:value} key-唯一的，不可变类型,value-任意类型。
集合：set去重,是因为它里边不可以存在相同的元素。显式的定义形式：{元素1, 元素2, 元素3},无序的

list_data = [1,2,3,3,4,4,5]
p = set(list_data)
print(p)   #input：{1, 2, 3, 4, 5}

第二天

基本单词解释

​ 大于：greater than
​ 小于：less than
​ 大于等于：great than
​ 小于等于：less than equal
等于：equal
​ +：and
​ —：subtract
​ *：multiple
​ / ： divide

一.元组的用法

​ count，index，append（extend）追加，remove移除，reverse反转，sort排序

tuple_data = (1,2,3,4,4,4,5)  
print(tuple_data.count(4)) #input：3   统计个数
print(tuple_data.index(4)) #input：3   统计4所在的下标

tuple1 = [1,2,3,4]
tuple2 = [5,6,7,8]
tuple1.append(tuple2)
print(tuple1)   #input[1, 2, 3, 4, [5, 6, 7, 8]]{}
tuple1 = [1,2,3,4]
tuple2 = [5,6,7,8]
tuple1.extend(tuple2)
print(tuple1)   #input：[1, 2, 3, 4, 5, 6, 7, 8]
#可迭代的有：元组，字符串

二.str的用法

a ="alex lnm"
print(a.center(50,"-"))   #给a两边打印—
print(a.count("l",0,5))  #计数
print(a.endswith("m"))  #判断结尾 返回true 或者fasle
print(a.startswith("a")) #判断开头

print(a.find("e"))   #字符查找，如果找到了，就返回索引，没找到就返回-1
print(a.isdigit())

print("23".isdigit())  #判断是否为整数

l = ["alex","jick","tom"]
print("-".join(l)) #拼接字符串 ，alex-jick-tom

a = a.replace("x","1",2)  #字符串替换，后面的2为替换换几个l
print(a)

print(a.split("l"))  #字符串分割 output： ['a', 'e1 ', 'nm']

list_data = [1,2,3,3,4,4,5]
p = set(list_data)
print(p)  #input：{1, 2, 3, 4, 5, 6, 7}
print(tuple(p))  #input：(1, 2, 3, 4, 5, 6, 7)copy：
在常量里面deepcopy和浅copy相同

#浅copy
list_data = [1,2,3]
copy_data = list_data.copy()
print(id(list_data))
print(id(copy_data))
print(id(list_data[0]))
print(id(copy_data[0]))
#input:
    2220683495680
    2220683596480
    2220678277424
    2220678277424
    
#深copy
from copy import deepcopy
list_data = [1,2,3]
copy_list = deepcopy (list_data)
print(id(list_data))
print(id(copy_data))
print(id(list_data[0]))
print(id(copy_data[0]))
#input:
    2220683846784
    2220683596480
    2220678277424
    2220678277424

三.列表的用法

​ sort，reverse
reverse只能做降序（不能做升序）

list = [1,2,3,4,5,6]
list.sort(reverse=True)
print(list)
list.sort(reverse=True)
print(list)

四.字典的用法

dict = {1:2,3:4,5:6}
print(dict[1])
print(dict[3])
print(dict[5])       #访问字典中的元素
print(dict.keys())
print(dict.values()) #取字典中的值
print(dict.items())  #访问字典中的所有元素
#update 字典合并
dict1 ={7:8,9:10}
dict.updata(dict1)
print(dict)

​ update的用法

dict_data1 ={"姓名":"张三","年龄":"18","班级":"通信"}
dict_data2 = {"爱好":"玩游戏"}
dict_data1.update(dict_data2)
print(dict_data1.items())
print(dict_data1.keys())
print(dict_data1.values() 

dict_items([('姓名', '张三'), ('年龄', '18'), ('班级', '通信'), ('爱好', '玩游戏')])
dict_keys(['姓名', '年龄', '班级', '爱好'])
dict_values(['张三', '18', '通信', '玩游戏'])

五.集合的用法

discard（用这个不会报错），remove(有就移除元素,没有就报错），add

set_data = {1,2,3}
set_data.discard(2)
set_data.add(4)
print(set_data)

第三天

一.切片

python使用下标访问的时候，可以有正的下标，也可以有负的下标，使用负的下标去访问的时候，从-1开始，正的下标从零开始
一个冒号的时候，相当于是我们两个冒号的缩写，相当于省略了步长step
切片：对序列切片，顾前不顾后 print(list_data[2:9:1]) #>=start,stop<,step

二.赋空值

 dict_data = None
 list_data = []
 list_data = list()
 print(list_data)
 tuple_data = ()
 tuple_data =tuple()
 dict_data = dict()
 set_data = set()

三.for循环语句

  for循环打印列表，元组，字典。enumerate的用法

dict = {1:2,3:4,5:6}
list = [1,2,3,4,5,]
tuple  = (1,2,3,4,5)
for i in dict:
    print(dict)
for i in list:
    print(list)
for i in (tuple):
    print(tuple)

for index,value in enumerate(list):
    print(index,value)    #返回下标和下标对应的元素

list_data = [1,2,3,4,5]
tuple_data = (6,7,8,9,0,)
dict_data = {"姓名":"张三","性别":"男","班级":"1801"}
for i in list_data:
    print(i)
for i in tuple_data:
    print(i)
for i in dict_data.keys():
    print(i)
for i in dict_data.values():
    print(i)
for i in dict_data.items():
    print(i)

	for循环打印99乘法表

  for i in range(1,10):
    for j in range(1,i+1):
        print(i,"*",j,"=",i*j,end = "\t")
    print()

break和continue一般都是配合if使用，达到某个条件的时候，停止或者跳出本次循环

for i in range(10):
    if i ==3:
        break   #停止循环，continue是跳出本次循环
    print(i)   #input: 0  1  2

四.if条件语句

# money = 1000
# mr_liang_value = 1500
# if money >= mr_liang_value:
#     print("购买诸葛亮成功")
# else:
#     print("金币不足")

#打印成绩
# score = 80
# if score<=60:
#     print("C")
# elif 85>=score>60:
#     print("B")
# else:
#     print("A")

五.while循环语句

​ 99乘法表

i = 1
while i < 10:
    j = 1
    while j <= i:
        print(i,"*",j,"=",i*j,end="\t")
        j = j+1
    i = i+1
    print()

六.运算符

算数运算符：+ - * / % // **
较运算符：== ！= > >= < <=
赋值运算符：= += -= *= /= %= **= //=
位运算符：& | ~ 就是进行1和0的操作， ^(异或，相同位取零，不同位取一)
相同相与的时候等于他本身
逻辑运算符：and(且) or(或) not(非,取反)
身份运算符：is is not
成员运算符：in not in （用来测试数据中是否包含了一系列的成员）
进制的转化
所有非零的数字都是真值

七.读取用户输入

name = input("What is your name?")
print("hello"+ name)

第四天

一.错误和异常（运行中）

ZeroDivisonError
IndexError（出现频率最高）
Exception

IndexError    KeyError   ZeroDivisonError 
LookupError
Exception  #所有错误的父类

建议：做精准的异常捕获，把父类异常放在最后，finally应用场景的时候，一般都是关闭或者清理的操作。
二.读写文件
UTF—8:可变长的字符集编码
gb2312,gbk
打开文件的方式：以读的方式打开，以写的方式打开

def open(file, *(重要） 代表打开（读或者写）那个文件
绝对路径/相对路径
mode=‘r’, *（重要的），代表打开文件的方式
读/写的方式，文本/二进制
buffering=None, 缓存
encoding=None, *（重要的），编码：UTF-8,GBK
errors=None, 错误处理：strict
newline=None, 新起一行
closefd=True): 关闭文件描述符（Linux中用的比较多）

file_obj = open("review.txt",mode='rt',encode="utf-8")
data = file_obj.read()
file_obj_w = open("huyi.txt",mode="w",encoding="utf-8")
file_obj_w.write(data)
file_obj.close()
file_obj_w.close()  
#copy  review.txt 到 huyi.txt

普通copy
file_obj = open("图片.jpg","rb")
data = file_obj.read()
file_obj_w =open("图片_2.jpg","wb")
file_obj_wwrite(data)
file_obj.close()
file_obj_w.close()

with的用法
with open("图片，jpg"，"rb") as file_obj:
 	 data = file_obj.read()
 	 with open("图片2.jpg","wb") as file_obj_w:
 	 	  file_obj_w.write(data)

Character Meaning

---

​ ‘r’ open for reading (default)
​ 默认方式：读
​ ‘w’ open for writing, truncating the file first
​ 写的方式打开，写先删除文件然后新建文件
​ ‘x’ create a new file and open it for writing
​ 写：创建新文件，为了写打开
​ ‘a’ open for writing, appending to the end of the file if it exists
​ 写的方式打开，然后追加在文件的末尾
​ ‘b’ binary mode
​ 二进制模式
​ ‘t’ text mode (default)
​ 默认：文本模式
​ ‘+’ open a disk file for updating (reading and writing)
​ 打开磁盘文件更新
​ ‘U’ universal newline mode (deprecated)
rb 2进制只读模式/wb 2进制创建模式，若文件已存在，则覆盖旧文件/ab 2进制追加模式，新数据会写到文件末尾

用python打开.py文件

f = open("3.13.py")
print(f.read())

三.模块

3.1 一个python文件(.py)就是一个模块
可以被其他模块引用
import 模块 （导入模块）
from 模块名 import 函数/变量/类
几个常用的模块：random,sys,os,re,copy

模块的调用
from copy import deepcopy   as  dc 

import copy   #导入多个模块用逗号分隔
copy.deepcopy()

四.包，输入和输出

格式化输出
name = 111
age = 18
print("my name is",name,"my age is",age)
print("my name is %s,my age is %d" % (name,age))
print(f"my name is {name},my age is {age}")
#input:my name is 111 my age is 18

format函数

print("my name is {},my age is {}".format(name,age))
print("my name is {0},my age is {1}".format(name,age))

^:居中对齐 ,<:左对齐,>:右对齐
print("{0:^5}{1:15}{2:^30}".format(“姓名”,“13800000000”,“陕西省西安市鄠邑区”))

人类可读（str），python解释器可读（repr）

第五天

一.函数

def function_name(arg-参数列表):
statement1
return values = 需要有返回值，要使用return,可以return多个值
形参：形式参数，定义函数时叫形参
实参：实际参数，实际传递时叫实参
函数也是数据类型

*args:参数的复数arguments: 可以传递多个参数
*args：是将传入的参数打包成一个元组，不确定传入参数的个数，使用 *args
**kwaargs：1个或多个关键字参数，并且把它打包成字典

def test_arg(arg1,arg2=None):
    print(arg1)
    print(arg2)
test_arg("arg1")
test_arg("arg1","arg2")
arg1：位置参数    arg2： 关键字参数

关键字参数必须放在列表的末尾，从第一个关键字参数开始，后边必须都是关键字参数

用函数打印99乘法表

def nine_miu_nine(number):
    if number in (1,2,3,4,5,6,7,8,9):
        for i in range(1,number+1):
            for j in range(1,i+1):
                print(i,"*",j,"=",i*j,end = "\t")
            print("\n")
    else:
        print("不合法")
nine_miu_nine(9)

# /前面是位置参数  *后面必须是关键字参数
def test_get(value1,value2,/,*,kwd1,kwd2,):
    print("test_get")
test_get(1,2,kwd1 = 5,kwd2 = 6)

文档字符串
怎么去对函数进行注解：参数的注解返回值的注解

list_data = [2,3,4,5,0,8,6,9]
list_data.sort()
print(list_data)

def function_sort(element):
    return element%2
list_data.sort(key=function_sort)

lambda表达式 定义格式：lambda argument：expression

list_data.sort(key = lambda element : element % 2)

python高阶函数
map，reduce，filter，zip
map的结果：取决于你最短的里面有几个元素，取决于你有几个列表
每个元素里有几个值，取决于返回值

list_data_1 = [1,2]
list_data_2 = [3,4,5]
list_data_3 = [6,7,8,9]

def function_test(i,j,x):
    return i + 1, j + 1,x + 1
for i in map(function_test,list_data_1,list_data_2,list_data_3):
    print(i)
#input：	(2, 4, 7)
		 (3, 5, 8)

map的返回值可以通过list转换，所以map obj是一个序列。
list_data = list(map(function_test,list_data_1,list_data_2,list_data_3))
filter：过滤
data = list(filter(lambda x : x % 2,[1,2,3,0])) #input：[1, 3]

reduce：迁移到functools这个模块中，将序列中的元素应用到两个参数的函数进行累积操作
from functools import reduce
data = reduce(lambda x,y : x*y ,[1,2,3,4,5])
print(data) #input:120
zip：输入的是可迭代的对象，输出：多个元组
结束的条件：其中最短的耗尽了
最后返回：zip object
zip obj有几个元素，取决于最短的可迭代对象长度
每个元素有几个值，取决于传了几个可迭代对象
chr：把数字转成字符
ord：把字符转成数字

import sys #我们和python解释器进行交互用的
for path in sys.path:
    print(path)

import os #operation system 是我们和操作系统进行交互的

#正则表达式：用特殊的字符去匹配你的字符

第六天

类里面可以包含那些东西
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f1qOX8KA-1620912256487)(F:%5Cpython%5Cnotbook%5Cpython%E7%AC%94%E8%AE%B0.assets%5Cimage-20210411212914691.png)]

类的组成：类属性，实例方法，类方法，静态方法
属性：数据属性，方法属性
数据属性：变量
方法属性：函数
继承：inherit

多继承：

class Animals(object):
    def __init__(self,name):
        self.name = name

    def run(self):
        print(f"{self.name} is running")

class Lion(Animals):
    pass
class Tiger(Animals):
    pass

lion = Lion("狮子")
tiger = Tiger("老虎")
print(lion.name)
print(tiger.name)
lion.run()
tiger.run()

单继承：
多态：

class Animals(object):
    def __init__(self,name):
        self.name = name
    def run(self):
        print(f"{self.name} is runing")

class Lion(Animals):
    pass
class Tiger(Animals):
    pass
class Elephant(Animals):
    pass
def play(animals):
    animals.run()
lion = Lion("Lion")
tiger = Tiger("Tiger")
elephant = Elephant("Elephant")
play(lion)
play(tiger)
play(elephant)

函数重载：根据参数的个数去调用

def test(arg1):
    print("test1")
def test(arg1,arg2):
    print("test2")
test(1,2)

第七天

super关键字：超级

闭包：能够读取其他函数内部变量的函数，函数里嵌套了一个函数
一定是嵌套函数
内层函数可以引用外层函数的变量（自由变量）

def outer():
    data = "data"
    def inner():
        print(data)
    return inner

test = outer()
test()   #input：data

global（）：显示全局变量
locals（）：显示一个局部变量
绑定操作七种
1.变量定义：a = 3
2.函数定义：def test()
3.函数的参数: def test(arg1,arg2)
4.类定义：将类名绑定到一个class对象上
5.import modulenname
6.for temp_variable in iterable: temp_variable是绑定操作
7.try except

自由变量：i就在闭包中
outer：全局变量，function，是绑定操作
data：局部变量，有绑定操作
inner：局部变量，有绑定操作
print（data）：inner函数中，data没有没有在inner中绑定

装饰器：在不改变原函数的情况下，对原函数的功能进行增强
装饰器的使用：@装饰器名称，放在被装饰函数上面
一次定义多次使用

import time
def log_time(func):
    def log_wrapper():
        print(time.ctime())
        func()
        print(time.ctime())
    return log_wrapper

@log_time
def func_test():
    time.sleep(3)
    print("123")

@log_time
def func_test2():
    time.sleep(2)
    print("456")

func_test2()
print("****************************************")
func_test()

列表推导式：for后面跟的是过滤的表达式，而不是对结果进行修改的
for循环前边是对我想要的结果

list_data_3 = [i for i in range(10)]
print(list_data_3,type(list_data_3))

list_data_3 = [i for i in range(10) if i % 2 ==1]
print(list_data_3)

字典推导式：

装饰器 类里面的

第八天

迭代器：实现迭代协议的对象
python什么叫实现迭代协议

__inter__:返回对象本身,这个意义在于让调用他的人知道他是一个迭代器，要		  使用return		
__next__:返回迭代器的下一个元素，这个是实现迭代器真正的过程
		如果到迭代器结尾，怎么去知道迭代器结束了，要抛出一个异常：StopIteration。
		这个用意：for循环的，判断循环结束是否捕获StopIteration异常来判断，如果有这个异常，循环结束，如果没有，循环继续执行

如果要用下标去访问迭代器的话，要实现__getitem__方法
next（iterator）：本质就是调用__next__

class MyIterator:
    def __init__(self,stop):
        self.start = -1
        self.stop = stop
    def __iter__(self):
        return self

    def __getitem__(self,item):
        return self.start + item + 1

    def __next__(self):
        self.start = self.start + 1
        if self.start < self.stop:
            return self.start
        else:
            raise StopIteration

data =  MyIterator(10)
# for i in data:
#     print(i)   #input：0 1 2 3 4 5 6 7 8 9
print(data[1])  #input：1

生成器(generator)：
特点：每次产生一个元素
yield表达式：yield experssion_list（表达式列表）
生成器函数：定义了一个函数，，且函数有使用yield
生成器:当一个生成器函数被调用的时候，它返回一个迭代器，称为生成器。然后这个生成器来控制生成器函数的执行。

#生成器函数：yield_test
def yield_test():
    yield"yield"
#生成器：data
data = return_test()
next(data)

正则表达式
用特殊字符去匹配字符串中的内容

import re
str_test = "AbcD"
pattern = "abcd"
print(re.match(pattern,str_test,re.I))
str_test = "aaabbbcccaaaddd"
pattern = "aaa"
print(re.search(pattern,str_test)) 

input:
<re.Match object; span=(0, 4), match='AbcD'>
<re.Match object; span=(0, 3), match='aaa'>

import re
str_test = "计算机,软件,网络,大数据"
print(re.subn(",","|",str_test,count=2))

input:('计算机|软件|网络,大数据', 2)

pattern

第九天

nt(i) #input：0 1 2 3 4 5 6 7 8 9
print(data[1]) #input：1

**生成器(generator)**：
特点：每次产生一个元素
yield表达式：yield experssion_list（表达式列表）
生成器函数：定义了一个函数，，且函数有使用yield
生成器:当一个生成器函数被调用的时候，它返回一个迭代器，称为生成器。然后这个生成器来控制生成器函数的执行。

#生成器函数：yield_test
def yield_test():
yield"yield"
#生成器：data
data = return_test()
next(data)

正则表达式
用特殊字符去匹配字符串中的内容

import re
str_test = “AbcD”
pattern = “abcd”
print(re.match(pattern,str_test,re.I))
str_test = “aaabbbcccaaaddd”
pattern = “aaa”
print(re.search(pattern,str_test))

input:
<re.Match object; span=(0, 4), match=‘AbcD’>
<re.Match object; span=(0, 3), match=‘aaa’>

import re
str_test = “计算机,软件,网络,大数据”
print(re.subn(",","|",str_test,count=2))

input:(‘计算机|软件|网络,大数据’, 2)

pattern


# **第九天**

正则表达式