python3-基础教程

目录

10 def 函数

11 函数 参数

12 函数默认参数

13 全局 & 局部变量, global & local

14 模块安装

15 读写文件1

16 读写文件2

17 文件读写3

18 class 类

19 类 init 功能

20 input 输入

21 元组 列表

22 列表 list

23 多维列表

24 字典 dictionary

25 import 载入模块

26 自己的模块

27 continue & break

28 错误处理 try

29 zip lambda map

30 浅复制&深复制, copy & deepcopy

1 Python threading 1 什么是多线程

32 Python multiprocessing 1 介绍

33 Python tkinter 1 什么是tkinter窗口

34 pickle 存放数据

35 set 找不同

36 RegEx 正则表达

函数

可以指定参数赋值更加清楚，如果不指定则按顺序赋值

def function(a,b):
    c = a + b
    print("the c is ",c)

function(1,2) #a=1,b=2
function(a=1,b=1)#a=1,b=2
function(b=2,a=1)#a=1,b=2

默认参数值

若如果在形参表当中已经对参数赋值，则在调用时可以不再赋值而函数会自动调用默认值，若在实参中重新赋值则丢弃默认值接受传递值

注意：但是要保证所有未给默认值的参数要在给定默认值参数之前

全局与局部变量

在函数外定义的变量就是全局变量在任何地方无论函数内外都可以被调用，但是你对在函数内部使用函数外部定义的全局变量时，需要如下使用：

a = None
def func():
    global a
    a = 20

首选如果你并不对全局变量做赋值操作时，那么你可以不需要 global语句直接使用，但是一旦要使用赋值语句的时候你就需要是a位于等号左边，这样相当于定义了一个局部变量，而对该变量赋值并不会改变函数的全局变量，因为变量同名就近原则，所以如果此时想用全局变量必须global

在函数内部定义的变量仅能在函数内部被调用

python文件读写

写文件

#打开文件
my_file = open('myfile.txt',"w")
#写入字符串
my_file.write(str)
#关闭文件
my_file.close()

#打开文件
my_file = open('myfile.txt',"a")
#追加写入字符串
my_file.write(appended_str)
#关闭文件
my_file.close()

'myfile.txt’是我们要打开的文件，如果是已经可以找到的文件则将该文件直接返回给my_file，并有后面参数的权限，如果没有对应的文件则会自己新建一个文件并返回给my_file

第二个参数是要以什么形式打开文件，常见参数：
w ： 写东西进去，并且每次写入会将以前内容覆盖
r ： 以只读形式打开只能查看，并不能写入
a ： 写东西进去，并且每次写入会接着以前内容不会覆盖

读文件

#以只读形式打开文件，这里的文件和写的时候不一样一旦没有会报错，一定打开已有文件进行读取
my_file = open('myfile.txt',"r")
#读取文件中所有内容
my_file.read(appended_str)
#读取文件中第一行内容，如果接着使用则读取下一行
my_file.readline(appended_str)
#读取文件中所有行内容，并且把每一行读的内容组织成字符串并作为一个元素，则所有行读取后的内容构成列表作为读取结果
my_file.readline(appended_str)
#关闭文件
my_file.close()

类(class)

基本定义

class Caculator:
    name="good Caculator"
    price =18
    def add(self,x,y):
        print(self.name)
        res = a + b
        print(res)
    def minus(self,x,y):
        res = a - b
        print(res)
    def times(self,x,y):
        res = a * b
        print(res)
    def devide(self,x,y):
        res = a + b
        print(res)

1.类一般包含类属性和类方法

2.类当中的方法分为两种一种是实例方法，一种是静态方法。

1）若如果为实例方法那么则方法的第一个参数就是self，就是对自身类的一个引用。则若如果调用需要实例化对象以后使用"对象.方法名()"调用函数,并且在实例方法中可以通过self.s属性调用类中定义的变量。

2）若无self相当于静态方法可以只直接使用"类名.方法名()"调用函数，然而"对象.方法名()"仍然奏效

类的初始化-init()方法

init方法是是对类中的属性进行初始化或者进行一些操作或者调用该类中的其他方法以及其他类以及内部的属性和方法

init方法适合其他函数一样的类方法，仍然需要保证第一个参数为self并且可以设置默认值

如果我们未定义该方法，那么类中会自动调用默认的构造方法即(无任何操作)：

def _init_ (self):

但是一旦定义了init方法，那么原来默认的构造方法就被抛弃，就以新的为构造函数进行初始化，定义类的时候会自动调用该方法，而定义类后面的括号就是构造函数的形参表。

input输入

a_input = input("please input a number:")

作用：将input函数的字符串形式的参数打印在屏幕上，并且接受键盘的输入值组织成字符串的形式并赋值给变量a_input
若如果你要得到特定类型的数据就要适用强制类型转换

a_input = int(input("please input a number:"))

元组(tuple) and 列表(list)

都是由一连串有序的元素构成

定义方法：

tuple：使用()定义或者直接定义

a_tuple = (12,23,46,78)
a_tuple = 12,23,46,78

list：使用[]定义

a_list = [12,23,46,78]

使用方法

循环依次处理元素：

for number in a_tuple:
    print(number)

for number in a_list：
    print(number)
    

循环依次按位取值：

for index in range(len(a_tuple)):
    print(number)


for index in range(len(a_list)):
    print(number)

1.len()函数作用是计算列表或者元组中元素的个数
2.range(n)是产生一个迭代器列表，从0迭代到n-1

列表专题

1.在最后追加元素：

a_list = [12,23,46,78]
a_list.append(0) #在列表最后追加元素0

2.指定位置插入元素：

a_list = [12,23,46,78]
a_list.insert(1,0) #在列表中序号为1的位置插入元素0

3.获得值对应元素索引：

a_list = [12,23,46,78]
a_list.insert(2) #获得列表当中第一次出现的2的索引

3.获得值对应元素索引：

a_list = [2,12,2,23,46,78]
a_list.count(2) #获得列表当中第一次出现的2的索引

4.统计出现次数指定值：

a_list = [2,12,2,23,46,78]
a_list.count(2) #输出列表中出现2的次数

5.删除最后一个值：

a_list = [12,23,46,78]
a_list.pop() #删除列表中最后一个值78

6.排序：

a_list = [12,23,46,78]
a_list.sort() #将列表从小到大排序并覆盖原有list
a_list.sort(reverse=True) #将列表从大到小排序并覆盖原有list

7.切片：

python列表从左至有从0为起始，从右至左移-1起始
:是从哪到哪的意思，如果一端空缺为无穷，左为负无穷，右为正无穷，且左右两端取值左闭右开

a_list = [12,23,46,78]
print(a_list[0:2])
print(a_list[:2])
print(a_list[1:])
print(a_list[:])

字典-dictionary

无序的元素构成的列表，且每一个元素都是一个键值对，其实就是一个改变索引值的列表，原来列表的索引值是确定的数字，现在可以是任意数字和字符串作为索引也就是冒号左端的东西成为键，而键对应存储的值仍叫值，值可以是任意类型的数、字符串、以及元组和列表甚至字典和函数

def function():
    return 29
a_dict = {'apple'：[1,2,3],"pear":{'a':2,'b':3},"bnana"：function()}
print(a_dict['pear']['a'])

运行结果:
2

定义方法

a_list = [1,2,3,4,5]
a_dict = {'apple'：1,"pear":2,"bnana"：3}

使用方法

1.使用键可以调用对用值

print(a_dict['apple'])

2.使用键可以删除对用值

del a_dict['apple']
print(a_dict)

3.在字典中插入一个元素

a_dict['orange'] = 20 #插入一个键值对 'orange':20
print(a_dict)

import官方模块的方式

1.import time

使用模块名.方法名/属性名调用

import time
print(time.localtime())#输出当前时间
print(time.time())#输出当前时刻是多少秒

2.import time as t

为模块起别名t,如果模块名过于长我们可以用t来代替去引用方法和属性

3.from time import time,localtime #引入多个逗号隔开

引入模块当中特定方法和属性，使用该模块内方法和属性不需要使用模块名调用，直接写函数名和属性名即可

import time
print(localtime())#输出当前时间
print(time())#输出当前时刻是多少秒

4.from time import * #引入多个逗号隔开

引入模块当中所有方法和属性，使用该模块内方法和属性不需要使用模块名调用，直接写函数名和属性名即可

import time
print(localtime())#输出当前时间
print(time())#输出当前时刻是多少秒

引入自己的模块

每一个脚本都可以叫做一个模块，我们调用的方式和引用官方的模块一样，直接把待引用的那块脚本（.py文件）也就是模块的文件名作为模块名之后和前面引用官方模块的方法和属性一样

但是需要注意的是如果直接使用文件名作为模块名导入需要保证导入和待导入脚本在同一个文件夹下，若如果不在两种解决方式

第一写出待导入文件相对于导入文件的路径之间用.连接上下关系

直接将要调用的文件放在和官方库下载在本地的文件夹下

循环中的continue与break

continue：跳过本轮循环

break：跳过当前循环

错误处理-try

try可以针对系统爆出来的错进行处理

注：暂时无read.txt文件时

file = open("read.txt",'r')

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZjjNCkKu-1612539503364)(F5194E4F71284F209C3A34FE1C3C095B)]

发现异常并打印

try：#尝试运行缩进代码块
    file = open("read.txt",'r')
except Exception as e:  #捕获所有Exception类型异常存储到e当中
    print(e)    #缩进部分为捕获异常后对异常的操作这里是打印异常

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G4BFfsw5-1612539503366)(F99A85E63A5F491D8F80C28B0EA5E63C)]

更多的操作

try：#尝试运行缩进代码块
    file = open("read.txt",'r+')
except Exception as e:  #捕获所有Exception类型异常存储到e当中

#如果没有文件会产生保存并该告诉你"there is no file named as read"并同时询问你"do you want to create a new file(y/n)"如果是y我们就创建一个改名字的文件，其他情况下什么都不做

    print("there is no file named as read")
    repond = input("do you want to create a new file(y/n)")
    if repond=='y':
        file = open("read.txt",'w')
    else:
        pass
        
#如果由该文件，则执行else缩进的代码块写入内容后并关闭
else:
    file.write("yyyyy")
    file.close()

上面的try和else模块是对立事件，如果try下缩进的代码块没有报错则执行后面的else，如果报错则实行except Exception as e:下缩进的对于异常处理的操作

map、zip、lambda

zip

将列表合并起来，是竖向的合并，zip是英文拉链的意思，我们两个列表相当于两个链条，经过拉锁以后链条两端的齿轮是一一对应起来的，这里也是一样将两个列表中对应位置元素组织成元组，但是并不只是可以将两个列表合并对于多个列表也可以，都是将对应位置元素合并成一个n元组，知道所有元素结束。

但是进过zip函数得到的是zip对象，若想可视化则需要将其转化为list()对象

a = [1,2,3]
b = [4,5,6]
zip(a,b)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ko2k5ZuK-1612539503367)(F468219928DF4320833AE0CBECA5EE71)]

list(zip(a,b))

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-raG64OS1-1612539503369)(8091B615EA604A0889F871DCD5B06FC8)]

可以zip多个列表

list(zip(a,a,b))

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v8G1m7pD-1612539503371)(DFD76848EBC34E93B7B87E15C883A46B)]

zip对象相当于一个迭代器的输出

for i,j in zip(a,b):
    print(i/2,j*2)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zfFuIehy-1612539503372)(A8550ACA3E1C471695B23BCD68498243)]

lambda

lambda和def的作用是一样的都是来定义一个函数，但是lambda通常用作定义代码较少的函数,而且使用lambda定义是后面不需要接函数名函数名放在等号左边二会直接接参数，所以又称匿名函数

def func1(x,y):
    return x+y
func1(2,3)

func2 = lambda x,y:x+y
func2(2,3)

运行结果：
5
5

map

map就是将参数列表和函数连接起来的运算，并运行后将结果组织成列表

map(func1,[1],[2])
#将列表[1]和[2]中的参数依次分别赋给func1中的参数x,y并计算结果
#如果func1有n个非默认参数需要将n个列表并且按顺序列表和func1参数依次连接，
依次将每个列表相同位的数值依次赋给函数求值，并将该值作为相同位置的结果在结果列表中

运行结果：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7PvVcVux-1612539503372)(3523281AD1744E5FBFF75137401350CA)]
输出的是map的对象，若如果想输出成列表形式，需要如下:

list(map(func1,[1],[2]))

运行结果：
[3]

输入更长的参数列表

list(map(func1,[1,3],[2,4]))
#首先将1,2依次赋给func1参数x,y并计算结果的3
#接着将3,4依次赋给func1参数x,y并计算结果为7
#相当于现将两个列表zip起来形成多个n元组，并将多个n元组依次赋给参数列表并计算结果

赋值复制 and 浅复制 and 深复制 (copy and deepcopy)

（赋值）伪复制

将一个列表赋值给另一个变量实现复制

a = [1,2,3]
b = a

将一个值赋给另一个列表，实现复制，[1,2,3]是在内存中开辟了一段内存地址并存储1,2,3,而a实际是对该块内存的引用即为该段内存起的别名,同样b也是对该块内存的引用即为该段内存起的别名,所以a和b都是对该块内存的引用控制的都是该块内存，所以无论通过a和b那个名字操控该块内存，都是同时对a和b产生影响，只是起了一个别的名字b，并没有真正开辟一段新空间去存储相同内容实现复制,所以有：

print(id(a)==id(b))

运行结果：
True

a和b对应内存同一个位置，实际上是一个东西改变任意一个都影响另一个

浅复制

import copy
a = [1,2,3]
c = copy.copy(a)
print(id(a)==id(c)

运行结果：
Flase

证明c和a变量对应内存当中并不是一个位置，不是一个东西，并且改变a或c中的任何一个元素并不会互相影响

import copy
a = [1,2,[3,4]]
c = copy.copy(a)
print(id(a)==id(c)
print(id(a[2])==id(c[2])
a[0]=11
print(c)
a[2][0]= 333
print(c)

运行结果：
False

True

[1,2,[3,4]]

[1,2,[333,4]]

我们从上面可以看出列表中的元素改变一个并不影响另一个，说明列表中的元素是重新开辟一段空间去存储类表中的元素，而对于列表中的对象元素就是列表，字典，元组等对象改变其中一个元素同时相互影响，因为对象存储的是地址并非存储值，所以当赋值的时候，浅拷贝只拷贝父对象，而不会拷贝子对象，子对象是共用的

深复制

而深度复制是完全复制所有的父对象和子对象，是实现一种id完全不同的一种复制，是开辟一块完全新的的空间并且将值复制一份存到新的空间当中

import copy
a = [1,2,[3,4]]
d = copy.deepcopy(a)
print(id(a)==id(d)
print(id(a[2])==id(d[2])

运行结果：
False

False

pickle 存放数据

保存python运算结果到本地目录上，并且将运算结果进一步其他的加工，我们将就需要包运算结果保存成pickle文件并随时提取进行加工，pickle可以保存列表、字典和变量等一些数据

保存pickle文件

import pickle
a_dict={'da':111,2:[23,1,4],'23':{1:2,'d':'sad'}}
#以二进制写入的方式打开文件pickle
file = open("pickle_example.pickle","wb")
#pickle.dump相当于挖土车，装载的是a_dict并倒入file当中
pickle.dump(a_dict,file)
#关闭文件
file.close()

打开pickle文件继续处理

import pickle
#以二进制读入的方式打开文件pickle
file = open("pickle_example.pickle","rb")
#使用pickle模块来读取file中能够读取的内容并存到另外一个字典当中
a_dict1 = pickle.load(file)
#关闭文件
file.close()
#打印读取内容
print(a_dict1)

可以使用下面代码代替上面代码，使用with可以自动关闭文件，防止忘记

同样写入的时候也可以使用with语句

import pickle
with open("pickle_example.pickle","rb") as file:
    a_dict1 = pickle.load(file)

print(a_dict1)

set

在列表或序列当中找到不同的地方，不重合的地方
char_list[‘a’,‘b’,‘c’,‘c’,‘d’,‘d’,‘d’]
比如上面这个列表当中有一个a和b、2个c、3个d找不同的就是将所有重复的东西剔除掉，只留下不同的地方

基本用法

print(set(char_list))
print(type(set(char_list)))

运行结果：

{‘a’,‘b’,‘c’,‘d’}

输出的结果是类似于字典的形式，以大括号形式表示，但是没有键对形式，是集合（set）形式，但是他返回的形式和字典一样是无序的，破坏了列表的有序性

我们可以将字符串想象成字符列表类似于上面的char_list,使用set会将字符串中以字符为元素进行出去冗余，而且会区分大小写因为大小写在内存中位置不同，而且会保留空格，因为空格也是一个字符

sentence = 'Welcome Back to This Tutorial'
print(set(sentence))

运行结果：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GilEcLlO-1612539503373)(DFB353C5CD4E438D96E94EBB517B0469)]

set当中不可以传入列表的列表，只能传入列表或者元组

char_list['a','b','c','c','d','d','d']
sentence = 'Welcome Back to This Tutorial'
print(set(sentence+char_list))

运算结果：报错

set的功能

向set中添加元素

char_list['a','b','c','c','d','d','d']
unique_list = set(char_list)
unique_list.add('a')
print(unique_list)
unique_list.add('x')
print(unique_list)

运行结果：

{‘d’,‘b’,‘c’,‘a’}

{‘d’,‘x’,‘b’,‘c’,‘a’}

结果分析当我们获得一个set类型的数据当我们想里边添加元素的时候会保持互异性如果里边已经有我们要添加的元素了，我们就可以不用添加了，若没有则需要添加

但是不可以添加一组数（列表）形式，只能单独加，即：

unique_list.add(['x','a'])

运行结果：报错

清空set

char_list['a','b','c','c','d','d','d']
unique_list = set(char_list)
unique_list.clear()
print(unique_list)

运行结果：
set() #空的set

在set中删除元素

char_list['a','b','c','c','d','d','d']
unique_list = set(char_list)
unique_list.add('x')
print(unique_list.remove('x'))
print(unique_list)

运行结果：

None

{‘d’,‘b’,‘c’,‘a’}

unique_list.remove(‘x’)做的是去除集合中的元素’x’,但是返回值是None，若想看去除元素之后的列表需要重新打印一遍，但是除去的元素一定是set中具有的元素，若移除不具有的元素会产生报错，若想避免该种情况可以使用discard函数，它对该种情况不会报错，但是不会减少任何元素

char_list['a','b','c','c','d','d','d']
unique_list = set(char_list)
unique_list.add('x')
print(unique_list.discard('y'))
print(unique_list)

运行结果：

None

{‘d’,’x’,‘b’,‘c’,‘a’}

求集合的交集

set1={'d','x','b','c','a'}
set2={'a','e','i'}
print(set1.intersection(set2))

运行结果：{‘a’}

求集合的差集

求set1具有的元素而set2不具有的元素组成的集合

set1={'d','x','b','c','a'}
set2={'a','e','i'}
print(set1.difference(set2))

运行结果：

{‘d’,’x’,‘b’,‘c’}

正则表达式(Regular Expression)

正则表达式匹配的东西就是在从含有许多固定格式的代码当中，比如网页代码找到我们所需要的信息

正则表达式 (Regular Expression) 又称 RegEx, 是用来匹配字符的一种工具. 在一大串字符中寻找你需要的内容. 它常被用在很多方面, 比如网页爬虫, 文稿整理, 数据筛选等等. 最简单的一个例子, 比如我需要爬取网页中每一页的标题. 而网页中的标题常常是这种形式.