# python

**Repository Path**: fakerlove/python

## Basic Information

- **Project Name**: python
- **Description**: python的知识库，内容学习。
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2021-06-11
- **Last Updated**: 2022-08-27

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 1. python 教程

<font color=red size=5>文章链接</font>

~~~bash
https://gitee.com/fakerlove/python
~~~



# 1.简介

## 1.1 介绍





## 1.2 安装

官方网址

~~~bash
https://www.python.org/
~~~

选择合适的版本，下载

~~~bash
https://www.python.org/downloads/release/
~~~

最新版本出到了3.9.5 。经典的版本3.7。尽量安装3.7

安装完成后查看python 版本

~~~bash
python --version
~~~



## 1.3 编译器

### jupyter

安装anconda

~~~bash
https://www.anaconda.com
~~~

下载地址

~~~bash
https://www.anaconda.com/products/individual-b#Downloads
~~~

![image-20210611100452164](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210611100452164.png)

点击下载安装就行，打开界面，安装jupyter

python的编译器，

![image-20210611101020158](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210611101020158.png)



点击完毕，就会出现以下情形

![image-20210611101213567](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210611101213567.png)



### pycharm

~~~bash
https://www.jetbrains.com/pycharm/
~~~

下载专业版，淘宝10几块钱，用一年





# 2. 入门

![image-20210611102112704](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210611102112704.png)



![image-20210611102125155](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210611102125155.png)



## 2.1 基本输入输出函数

> input(),eval(),print()

### print()

* 输出单纯的字符串

~~~python
print("hello--word")
~~~

运行效果如下

![image-20210611102143633](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210611102143633.png)



* 输出一个或者多个变量

~~~python
a=123
print(a)
~~~

运行效果如下

![image-20210611102243831](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210611102243831.png)

~~~python
a=123
b=456
print(a,b)
~~~

* 混合输出字符串

~~~python
print("输出字符串模板".format(变量1,变量2))
~~~

例子

~~~python
a=123
b=456
print("a的值为{}，b的值为{}".format(a,b))
~~~

{}就是槽位，输出字符串的模板

输出结果如下

![image-20210611103450990](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210611103450990.png)

> 注意点，print () 函数会在末尾自动添加换行，如果不想换行
>
> ~~~bash
> a=123
> b=456
> print(a,end="")
> print(b)
> ~~~
>
> 结果如下
>
> ![image-20210611103958741](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210611103958741.png)



### input()

通过控制台获取字符串，无论用户输入什么，都以字符串的形式返回结果

~~~python
a=input("请输入一行字符串")
print(a)
~~~

结果如下

![image-20210611104441575](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210611104441575.png)

### eval()

能够以python 表达式的方式解析并执行字符串，并将结果返回

~~~python
a=eval("1.2+3.4")
print(a)
~~~

![image-20210611160858392](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210611160858392.png)



通常结合input 函数，获取想要字符串

~~~python
a=eval(input("请输入数字"))
print(a*2)
~~~

![image-20210611160937758](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210611160937758.png)





## 2.2 变量和保留字

### 变量

python 命名规则允许采用大写字母，小写字母，数字，下划线和汉字等字符及其结合给变量命名，但是名字的首字符不能是数字，中间不能出现空格，标识符名称不能与Python 的保留字相同。大小写敏感

~~~python
a=99
a=a+1
print(a)
~~~

汉字也是可以作为变量的

~~~python
我的名字=99
我的名字=我的名字+1
print(我的名字)
a_b=99
a1_c=a_b+我的名字
print(a1_c)
~~~

### 保留字

33个保留字

|  and  | as   | assert | break    | class  | continue |
| :---: | ---- | ------ | -------- | ------ | -------- |
|  def  | del  | elif   | else     | except | finally  |
|  for  | from | False  | global   | if     | import   |
|  in   | is   | lambda | nonlocal | not    | None     |
|  or   | pass | raise  | return   | try    | True     |
| while | with | yield  |          |        |          |

## 2.3 数据类型

### 2.3.1 数字类型

#### 1) int整形

10 进制

16进制(0x或0X)

8进制0o开头

二进制(0b或者0B开头)

~~~python
print(0b11)
~~~

结果如下

![image-20210611152905418](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210611152905418.png)



~~~python
print(0xb1)
~~~

结果如下

![image-20210611152950494](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210611152950494.png)

#### 2) float浮点型

浮点数必须带有小数部分，小数部分可以是0

1010是整数，1010.0是浮点数

##### 科学计数法

* 一般表示

* 科学计数法

  浮点数只能是十进制

  ~~~python
  print(1.23234e2)
  ~~~

![image-20210611155051497](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210611155051497.png)

~~~python
print(1.23234e-2)
~~~

![image-20210611155040378](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210611155040378.png)

##### pow(x,y)

pow(x,y),用来计算$x^y$的值

~~~python
a=pow(2,3)
print(a)
~~~

结果为

~~~bash
8
~~~

##### 浮点数的问题

~~~python
a=pow(0.2,3)
print(a)
~~~

结果如下

![image-20210611162700815](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210611162700815.png)

尾数会根据二进制运算确定产生，尾数是不确定的。

#### 3) complex复数

~~~python
a=12+4j
print(a.real)
print(a.imag)
~~~

结果如下，打印实数部分和虚数部分

![image-20210611163105097](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210611163105097.png)

### 2.3.2 字符串

在Python中，加了引号的字符都被认为是字符串，其声明有三种方式，分别是：单引号、双引号和三引号；Python中的字符串有两种数据类型，分别是str类型和unicode类型，str类型采用的ASCII编码，无法表示中文，unicode类型采用unicode编码，能够表示任意字符，包括中文和其他语言。

python有两个序号体系

![image-20210611155233697](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210611155233697.png)



~~~python
print("人生几何，对酒当哥？"[1:4])
print("人生几何，对酒当哥？"[-4:-1])
~~~

![image-20210612104724833](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210612104724833.png)



#### 多行字符串

~~~python
print("""sda
sada
sdad
asdada""")
~~~

输出结果

~~~bash
sda
sada
sdad
asdada
~~~

**反斜杠\可以实现续行**

~~~python
print("dsa\
sada\
asdadsa")
~~~

结果为

~~~python
dsasadaasdadsa
~~~

#### 转义字符串

**\和其他符号组合，称为转移字符**

**使用\实现引号**

~~~python
print("\"青青子衿，悠悠我心\"")
~~~

![image-20210612104501817](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210612104501817.png)

原本\n表示的是换行

~~~python
print("kkk\\n 悠悠我心")
~~~

![image-20210612104554699](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210612104554699.png)

#### 字符串切片

字符串[x:y:z]

x 开始位置

y 结束位置

z表示步长

~~~python
print("123456"[::-1])
print("123456"[::2])
~~~

![image-20210612105126741](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210612105126741.png)

-1 表示索引号减1

#### 字符串的格式化

模板字符串.format(逗号分隔的参数)

槽除了包括参数序号，还可以包括格式控制信息，用来控制参数显示的个数

{参数序号:格式控制标记}

| 填充 | 用于填充的单个字符                    |
| ---- | ------------------------------------- |
| 对齐 | >右对齐<左对齐 ^居中对齐              |
| 宽度 | 槽的设定输出宽度                      |
| ，   | 表示数字分千位分隔符                  |
| .    | 表示精度                              |
| 类型 | 整数类型b,c,d,o,x,X.浮点数类型e,E,f,% |

c 表示Unicode字符

例子

~~~python
print("{}说:你是大{}".format("我","笨蛋"))
print("{1}说:你是大{0}".format("我","笨蛋"))
print("{0:%<25}啦啦啦".format("笨蛋"))
print("{0:%^25}啦啦啦".format("笨蛋"))
print("{0:%^15}啦啦啦".format("笨蛋"))
print("{0:,}你好呀".format(12314))
print("{0:.2f}".format(12334.4524234))
print("{0:.2}".format(12334.4524234))
print("{0:.2}".format("sad群无sad"))
print("{0:b},{0:d},{0:o},{0:x},{0:X},{0:c}".format(123))
~~~

结果如下

![image-20210612111144817](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210612111144817.png)



#### 字符串操作

| 操作符      | 描述                                     |
| ----------- | ---------------------------------------- |
| x+y         | 连接两个字符串x和y                       |
| x*n或者n\*y | 复制n次字符串x                           |
| x in s      | 如果x 是s 的子串，返回true,否则返回false |

~~~python
name="我是大笨蛋"*3
print(name)
a ="是"
print(a in name)
~~~

字符串函数

* len(x)

  返回字符串长度

* str(X)

  返回字符串

* chr(X)

  返回Unicode编码x对应的单字符

* ord(X)

  返回单字符x 表示的unicode编码

* hex(X)

  返回整数x对应十六进制数的小写形式字符串

* oct(X)

  返回整数x对应八进制的小写形式字符串

###  2.3.3 布尔型

和其他编程语言一样，Python布尔类型也是用于逻辑运算，有两个值：True（真）和False（假）。



### 2.3.4 列表list

列表是Python中使用最频繁的数据类型，集合中可以放任何数据类型，可对集合进行创建、查找、切片、增加、修改、删除、循环和排序操作。

~~~python
s=["sda",1231]
print(s)
print(type(s))
~~~

![image-20210612165139060](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210612165139060.png)



可以使用在循环中

~~~python
a=[121,23,[231,"3312"],"231"]
for item in a:
    print(item*2)
~~~

![image-20210612165926630](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210612165926630.png)



列表的切片

列表[N:M:K]

从N 到M 不包括M，的元素组成新的列表，当K存在时，K 为步长

列表的操作方法

append()方法

~~~python
ls=["风清扬","令狐聪","东方不败"]
ls.append("欧阳锋")
print(ls)
~~~

insert(1,"")

~~~python
ls=["风清扬","令狐聪","东方不败"]
ls.append("欧阳锋")
print(ls)
ls.insert(1,"郭靖")
print(ls)
~~~

clear()

remove()

reverse()

翻转函数

~~~python
ls=["风清扬","令狐聪","东方不败"]
print(ls)
ls.reverse()
print(ls)
~~~



### 2.3.5 元组tuple

元组和列表一样，也是一种序列，与列表不同的是，元组是不可修改的，元组用”()”标识，内部元素用逗号隔开。

~~~python
ls=('风清扬', '令狐聪', '东方不败')
print(ls,type(ls))
~~~

![image-20210613103414296](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210613103414296.png)



元组的可操作的方法

~~~python
ls=('风清扬', '令狐聪', '东方不败')
print(ls,type(ls))
# 东方不败在元组李有多少个
print(ls.count("东方不败"))
# 第一次出现东方不败的索引值
print(ls.index("东方不败"))
print(ls[1])
~~~

![image-20210613103617019](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210613103617019.png)

### 2.3.6 字典dict

字典是一种键值对的集合，是除列表以外Python之中最灵活的内置数据结构类型，列表是有序的对象集合，字典是无序的对象集合。是一种键值对

~~~python
ls={"a":"火影","b":"sada"}
ls[20]='dsa'
print(ls,type(ls))
print(ls.items())
print(ls.get("a"))
~~~

![image-20210613111536561](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210613111536561.png)



字典的操作函数

| 操作函数   | 描述                  |
| ---------- | --------------------- |
| len(d)     | 字典d的元素个数(长度) |
| min(d)     | 字典d 中键最小值      |
| max(d)     | 字典d 中的键最大值    |
| dict()     | 生成一个空字典        |
| d.keys()   | 键值信息              |
| d.items()  | 键值对信息            |
| d.delete() | 删除所有的键值对      |

for 循环遍历内容

~~~python
ls={"a":"火影","b":"sada"}
for item in ls:
    print("键为{}，值为{}".format(item,ls.get(item)))
~~~



### 2.3.7 集合set

集合是一个无序的、不重复的数据组合，它的主要作用有两个，分别是去重和关系测试。

~~~python
s={100,"1231",79.9,79.9}
print(s)
print(type(s))
~~~

![image-20210612163556120](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210612163556120.png)

#### 集合的运算

集合类型有4个操作符，交集，差集，补集，并集

| 操作 | 结果 |
| ---- | ---- |
| s-t  | 差集 |
| s&t  | 交集 |
| s^t  | 补集 |
| s\|t | 并集 |
|      |      |

~~~python
s={100,"1231",79.9,79.9}
t={100,"7777","1231",1234}
print(s-t)
print(s&t)
print(s^t)
print(s|t)
~~~

![image-20210612163928643](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210612163928643.png)

#### 集合的方法

S.add(X)

添加元素

S.remove(X)

移除元素

x in S

判断元素是否在S中

set()

设置集合对象





## 2.4 表达式赋值语句

产生或计算新数据值的代码片段称为表达式

~~~python
print(1024*32)
print("对酒当歌，人生几个"+"譬如朝鹿，去日苦劝")
~~~

同步复制语句

~~~python
a,b=3,4
a,b=b,a
print(a,b)
~~~

结果

![image-20210611160612126](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210611160612126.png)





## 2.5 数字运算

| 操作符 | 描述                                         |
| ------ | -------------------------------------------- |
| x+y    | x和y 之间的和                                |
| x-y    | x与y之间的差                                 |
| x*y    | x和y之间的积                                 |
| x/y    | x与y 之间的商，结果为浮点数                  |
| x//y   | x与y之间的整数商，及不大于x与y之商的最大整数 |
| x%y    | x与y 之商的余数，也称为模运算                |
| -x     | x的复数                                      |
| x**y   | x的y次幂，即$x^y$                            |

增强赋值运算符

+=，-=，*=，/=，//=,%=,\*\*= 

注：

数值运算可能改变结果的数据类型，类型的改变

* 整数和浮点数混合运算是，输出结果是浮点数

* 整数之间运算，产生的结果与操作符有关

  | 函数               | 意义                                                        |      |
  | ------------------ | ----------------------------------------------------------- | ---- |
  | abs(X)             | x 的绝对值                                                  |      |
  | divmod(X,Y)        | 结果(X//Y,X%Y)                                              |      |
  | pow(X,Y[,z])       |                                                             |      |
  | round(X[,ndigits]) | 对x四舍五入，保留ndigits 位小数，round(X)返回四舍五入的整数 |      |
  | max(x1,x2)         |                                                             |      |

![image-20210612103115741](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210612103115741.png)

* 整数或浮点数与复数运算，输出结果是复数





# 3. 控制结构

## 3.1 判断条件

|      |          |
| ---- | -------- |
| <    | 小于     |
| >    | 大于     |
| <=   | 小于等于 |
| >=   | 大于等于 |
| ==   | 等于     |
| !=   | 不等于   |

还有保留字

not or and

~~~python
print(not False)
print((1>0 ) and (5<6))
print((1>0 ) or (5>6))
~~~







## 3.2 条件语句

### 单分支结构

~~~python
s=3
if s%2==1:
    print("是奇数")
~~~

结果

~~~bash
是奇数
~~~



### 二分支结构

~~~python
s=4
if s%2==1:
    print("是奇数")

else:
    print("是偶数")
~~~

### 多分支结构

~~~python
s=90
if s<60:
    print("不及格")

elif s<80 and s>=60:
    print("良好")
else :
    print("优秀")
~~~





## 3.3 循环语句

### 遍历循环 for

for 循环变量 in 遍历结构:

  语句块

~~~python
for item in "Python":
    print(item)
~~~

遍历结构可以是字符串，文件，或者range(),对象结构

~~~python
for item in range(3,20,2):
    print(item)
~~~

break 跳出保留字

~~~python
for item in range(3,20,2):
    print(item)
    if(item==11):
        break;
~~~

![image-20210612152123728](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210612152123728.png)



continue 结束当前循环的。

~~~python
for item in range(1,10,1):
    if(item==6):
        continue;
    print(item)
~~~

![image-20210612152232945](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210612152232945.png)



### 无限循环 while

while 条件:

 语句块

~~~python
n=0
while n<10:
    n+=1
    print(n)
~~~

还有while else ,当while 循环正常结束之后，程序会继续执行else 语句中的内容，else 语句只在循环正常 执行后才执行，因此可以在语句块2 中放置判断循环执行情况的语句

正常结束情况

~~~python
n=0
while n<10:
    n+=1
    print(n)
else:
    print("循环正常结束")
~~~

![image-20210612153513468](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210612153513468.png)

不正常的情况，比如通过break 跳出

~~~python
n=0
while n<10:
    n+=1
    if n==5:
        break
    print(n)
else:
    print("循环正常结束")
~~~

![image-20210612153443556](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210612153443556.png)

## 3.4 异常处理

try:

语句块

except:

语句块

~~~python
try:
    a=1/0
except:
    print("对不起执行了异常处理")
~~~



# 4. 函数

## 4.1 函数的基本使用

def 函数名称(参数列表):

  函数体

return 返回值列表

~~~python
def loop(n):
    for item in range(n):
        print(item)
    print("循环结束")
    return n
a=loop(2)
print("返回结果为{}".format(a))
a=loop(3)
print("返回结果为{}".format(a))
a=loop(1)
print("返回结果为{}".format(a))
~~~



![image-20210612154548546](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210612154548546.png)





## 4.2 函数的参数传递

~~~python
def heart(a):
    allChar=[]
    for y in range(12, -12, -1):
        # 每行字母集合
        lst = []
        temp = ''
        for x in range(-30,30,1):
            # 心型线公式
            formula = ((x*0.05)**2+(y*0.1)**2-1)**3-(x*0.05)**2*(y*0.1)**3
            # 在心型线内，填充字母
            if formula<=0:
                 temp += a[(x) % len(a)]
            else:
                # 心型线外填充空格
                 temp += ' '
            #  把每个元素追加进去
        lst.append(temp)  
        # 添加每行字母与、
        allChar += lst
    print('\n'.join(allChar))
    
heart("Python")
~~~

![image-20210612161252920](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210612161252920.png)



函数的 参数在定义时可以指定默认值，当函数被调用时，如果没有传入对应的参数值，则使用函数定义时的默认值替代

def 函数名(非可选参数列表，可选参数列表=默认值)

  函数体

  return 返回值列表

## 4.3 变量的作用域

根据程序中变量所在的位置和作用范围，变量分为局部变量和全局变量。

局部变量指在函数内部使用的变量，仅在函数内部有效，当函数退出时变量将不在。

全局变量指在函数之外定义的变量，在程序执行全过程有效，全局变量在函数内部使用时，需要提前使用保留字global 申明



# 5. 文件

## 5.1 文件的使用

文件的类型

* 文本文件，由单一特定的编码的字符组成
* 二进制文件，二进制文件由0和1组成，文件内部数据的组织格式与文件用途有关比如视频和图片

 只读(r, rb)  只写(w, wb) 追加(a, ab)  r+读写  w+写读  a+写读(追加写读)

| 模式 | 使用描述                                                 |
| ---- | -------------------------------------------------------- |
| r    | 只读模式，文件不存在，报错FileNotFounError               |
| w    | 覆盖写模式，文件不存在则创建，存在则完全覆盖源文件       |
| x    | 创建写模式，文件不存在则创建，存在则报错，文件以及存在   |
| a    | 追加写模式，文件不存在则创建，存在则在源文件最后追加内容 |
| b    | 二进制文件模式                                           |
| +    | 和r/w/x/a 一同使用，在原本功能基础上同时增加读写功能     |



### 5.1.1 读操作

```php
try:
    f = open(r"C:\Users\20346\Desktop\1.txt", "r", encoding="UTF-8")
    content = f.read()
    print(content)
except BaseException as e:
    print(e)
finally:
    f.close()
```

结果为：

~~~bash
大家都不的目的地
~~~

加上b 就是以二进制的方式读取，一般用于图片，MP3,视频

```python
try:
    f = open(r"C:\Users\20346\Desktop\1.txt", "rb")
    content = f.read()
    print(content)
except BaseException as e:
    print(e)
finally:
    f.close()
```

结果为：

~~~bash
b'\xe5\xa4\xa7\xe5\xae\xb6\xe9\x83\xbd\xe4\xb8\x8d\xe7\x9a\x84\xe7\x9b\xae\xe7\x9a\x84\xe5\x9c\xb0  '
~~~

还有其他方法

read() 将文件中的内容全部读取出来. 弊端: 占内存. 如果文件过大.容易导致内存崩溃

read(n) 读取n个字符. 需要注意的是. 如果再次读取. 那么会在当前位置继续去读而不 是从头读, 如果使用的是rb模式. 则读取出来的是n个字节

readline() 一次读取一行数据, 注意: readline()结尾, 注意每次读取出来的数据都会有一 个\n 所以呢. 需要我们使用strip()方法来去掉\n或者空格

readlines()将每一行形成一个元素, 放到一个列表中. 将所有的内容都读取出来. 所以 也是. 容易出现内存崩溃的问题.不推荐使用

seek()文件读取指针。



可能会报错

~~~bash
OSError: [Errno 22] Invalid argument: '\u202aC:\\Users\\yyqhk\\Desktop\\1.csv'
~~~

解决方法

只需从写换个地方复制路径或则重新手动输入一次就解决了

![img](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/20180111211206376)



1.txt 内容

```php
+++++1.txt+++++
第一行的内容
第二行的内容
第三行的内容
第四行的内容
第五行的内容
第六行的内容
第七行的内容
+++++1.txt++++++
```

代码部分 

```python
try:
    f = open(r"C:\Users\20346\Desktop\1.txt", "r+", encoding="UTF-8")
    content = f.read()
    f.seek(0)  # 光标移动到开头
    content1 = f.read(3)
    f.seek(0)  # 光标移动到开头
    content2 = f.readline()
    f.seek(0)  # 光标移动到开头
    content3 = f.readlines()

    print("一次读取全部\n"+content+"\n")
    print("一次读取三个字符，根据read(n) ,其中的n \n " + content1+"\n")
    print("一次读取一行 \n" + content2+"\n")
    print("全部读取，但是放入一个列表里\n" )
    for i in content3:
        print(i)

except BaseException as e:
    print(e)
finally:
    f.close()
```

结果为：

```
一次读取全部
+++++1.txt+++++
第一行的内容
第二行的内容
第三行的内容
第四行的内容
第五行的内容
第六行的内容
第七行的内容
+++++1.txt++++++

一次读取三个字符，根据read(n) ,其中的n 
 +++

一次读取一行 
+++++1.txt+++++


全部读取，但是放入一个列表里

+++++1.txt+++++

第一行的内容

第二行的内容

第三行的内容

第四行的内容

第五行的内容

第六行的内容

第七行的内容

+++++1.txt++++++
```

### 5.1.2 写的操作

写的时候注意. 如果没有文件. 则会创建文件, 如果文件存在. 则将原件中原来的内容删除, 再 写入新内容

```python
try:
    f = open(r"C:\Users\20346\Desktop\1.txt", "w", encoding="UTF-8")
    f.write("金毛狮王")
    f.flush()  # 刷新. 养成好习惯

except BaseException as e:
    print(e)
finally:
    f.close()
```

### 5.1.3 读写操作

对于读写模式. 必须是先读. 因为默认光标是在开头的. 准备读取的. 当读完了之后再进行 写入. 我们以后使用频率最⾼的模式就是r+

```python
try:
    f = open(r"C:\Users\20346\Desktop\1.txt", "r+", encoding="UTF-8")
    content = f.read()
    print(content)
    f.write("麻花藤的最爱")
    f.flush()
    f.seek(0)
    content = f.read()
    print(content)

except BaseException as e:
    print(e)
finally:
    f.close()
```

结果为：

金毛狮王1
金毛狮王1麻花藤的最爱

### 5.1.4 写读操作

 w+

先将所有的内容清空. 然后写入. 最后读取. 但是读取的内容是空的, 不常用

```python
f = open(r"C:\Users\20346\Desktop\1.txt", "w+", encoding="UTF-8")
f.write("哈哈")
content = f.read()
print(content)
f.flush()
f.close()
```

### 5.1.5 追加操作

a+模式下, 不论先读还是后读. 都是读取不到数据的.

```python
try:
    f = open(r"C:\Users\20346\Desktop\1.txt", "a+", encoding="UTF-8")
    f.write("马化腾")
    content = f.read()
    print("指针在尾部，所以答应出来的东西为空"+content+"\n")
    f.flush()
    f.seek(0)
    content = f.read()
    print("指针在第一位，所以有东西打印 "+content)

except BaseException as e:
    print(e)
finally:
    f.close()
```

结果为：

~~~python
指针在尾部，所以答应出来的东西为空
指针在第一位，所以有东西打印 金毛狮王1麻花藤的最爱马化腾马化腾
~~~

6.with 上下文管理器

```python
s = ["大家好\n", "我是joker\n", "我今年18岁\n"]
with open(r"C:\Users\20346\Desktop\1.txt", "r+", encoding="UTF-8") as f:
    f.writelines(s)
```



## 5.2 csv

使用csv形式，来存储文件

读取文件

~~~python

~~~







# 6. 面向对象

面向过程

c

面向对象

c++,java,python





## 6.1 类

对具有相同属性好方法的一组对象的描述或定义

~~~python
class 类的名称:
  类的说明文档
  def _init_(self,...):
    pass
  ...
~~~

\_\_init\_\_()是一种特殊的方法，当根据类创建对象时，python 会自动运行

pass 语句表示后面暂时没有更多信息，可以在后续的编程中完善

~~~python
class Car():
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    def kk(self,n):
        print("{}----{}".format(self.year,n))
        
myCar=Car(2012,21,33)
myCar.kk("312")
print(myCar.month)
~~~

![image-20210624095408395](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210624095408395.png)

修改属性值

对象.属性=值





## 6.2 继承

当编写的类是另一个现成类的特殊版本，可使用继承

一个类继承另一个类，它将自动获得另一个类的所有属性和方法，原来的类称为父类，而新的类称为子类

~~~python
class 父类名():
  def __init__(self,参数):
    ....
    
class 子类名(父类名):
  def __init__(self，参数):
    super().init(...)
    
~~~

子类必须写在父类后面，如果不在一个文件类，就必须进行import.。

父类定义的方法，子类都可以使用

子类创建的方法，父类不能够进行使用

~~~python
class Car():
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    def kk(self,n):
        print("{}----{}".format(self.year,n))
        
# 新能源汽车，继承关系，继承了Car ,然后能够使用父类的方法
class ElecCar(Car):
    def __init__(self,year,month,day):
        super().__init__(year,month,day)
    

        
myCar=ElecCar(2012,21,33)
myCar.month=33
myCar.kk("312")
print(myCar.month)
~~~



## 6.3 导入类

* 导入单个类

  from 模块名 import 类名

* 从一个模块中导入多个类

  from 模块名 import 类名1，类名2

* 导入整个模块

  import

* 导入模块中的所有类

  from 模块名 import *

 

~~~python
import cv2
~~~



## 6.4 库

标准库

程序语言自身拥有的库，可以直接使用，无需安装

time,random,turtle库

~~~python
import time
import random
import turtle

# 时间模块
loctime = time.localtime()
ti = time.time()
print(ti)
print(loctime)

# 随机数
ran = random.random()
print(ran)
print(random.randint(1, 9))

# 绘图模块
turtle.screensize(800, 600)
# 画笔宽度为1
turtle.pensize(1)
# 画笔颜色
turtle.pencolor('black')
# 绘画速度
turtle.speed(10)

TJT_color = {1: 'white', -1: 'black'}
color_list = [1, -1]
# 半径
R = 100
for c in color_list:
    print(c)
    # 获取该半边的填充色
    turtle.fillcolor(TJT_color.get(c))

    turtle.begin_fill()  # 开始填充
    # 开始画出半边的轮廓
    turtle.circle(R / 2, 180)
    turtle.circle(R, 180)
    turtle.circle(R / 2, -180)
    turtle.end_fill()  # 结束填充 上色完成

    # 绘制该半边的鱼眼
    turtle.penup()  # 提起画笔，移动不留痕
    turtle.goto(0, R / 3 * c)  # 移动到该半边的鱼眼的圆上 R/3*c 表示移动到哪边
    turtle.pendown()  # 放下画笔，移动留痕
    turtle.fillcolor(TJT_color.get(-c))  # 获取鱼眼填充色, 与该半边相反
    turtle.begin_fill()
    turtle.circle(-R / 6, 360)
    turtle.end_fill()

    # 回到原点，为下一循环的开始做准备
    turtle.penup()
    turtle.goto(0, 0)
    turtle.pendown()

~~~



### 6.4.1 时间库

* 时间处理

  ~~~python
  time.time()
  time.gmtime()
  time.localtime()
  time.ctime()
  ~~~

  

* 时间格式化

  ~~~python
  time.mktime()
  time.strftime()
  time.strptime()
  ~~~

  例子

  ~~~python
  import time
  t=time.localtime()
  print(t)
  #将struct_time 对象t转换成时间戳，注意t 代表当地时间
  print(time.mktime(t))
  # 函数是时间格式化最有效的方法，几乎可以以任何通用格式输出时间，该方法利用一个格式字符串，对时间格式进行表达
  print(time.strftime("%Y-%m-%d %H:%M:%S",t))
  ~~~

  ![image-20210624162241239](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210624162241239.png)

  

  

* 计时

  ~~~python
  time.sleep()
  time.monotonic()
  time.perf_counter()
  ~~~

  perf_couter 返回一个性能计数器的值（在分秒内）即一个具有最高可用分辨率的时钟，以测量短时间，它包括了在睡眠时间

  

### 6.4.2 随机数

~~~python
import random

# 随机生成一个0-1以内的随机小数
ran=random.random()
print(ran)
# 如果seed() 不给参数，里面的参数为系统时间
# seed(1),如果给了固定值，随机出来的数也是固定值
random.seed(1)
ran=random.random()
print(ran)
random.seed(1)
dom=random.random()
print(dom)

~~~



randint和randomrange

~~~python
import random

in1=random.randint(1,10)
print("随机整数{}".format(in1))
ra=random.randrange(1,10,3)#[1,4,7]
print(ra)
# 随你返回(a,b)，a-b 之间的一个小数
kk=random.uniform(10,31)
print(kk)

# choice(seq)返回序列中随机一个数
c=["石头","剪刀","布"]
print(random.choice(c))

# shuffle(seq) 将序列类型中元素随机排列，返回打乱后的序列
a=["你好","哈哈","sda","嗯嗯"]
random.shuffle(a)
print(a)
# sample(pop,k) 从pop 类型中随机选取k个元素，一列表类型返回
a=["你好","哈哈","sda","嗯嗯"]
print(random.sample(a,2))
~~~



### 6.4.3 图形绘制库turtle

打印太极图

~~~python
import turtle
# 绘图模块
turtle.screensize(800, 600)
# 画笔宽度为1
turtle.pensize(1)
# 画笔颜色
turtle.pencolor('black')
# 绘画速度
turtle.speed(10)

TJT_color = {1: 'white', -1: 'black'}
color_list = [1, -1]
# 半径
R = 100
for c in color_list:
    print(c)
    # 获取该半边的填充色
    turtle.fillcolor(TJT_color.get(c))

    turtle.begin_fill()  # 开始填充
    # 开始画出半边的轮廓
    turtle.circle(R / 2, 180)
    turtle.circle(R, 180)
    turtle.circle(R / 2, -180)
    turtle.end_fill()  # 结束填充 上色完成

    # 绘制该半边的鱼眼
    turtle.penup()  # 提起画笔，移动不留痕
    turtle.goto(0, R / 3 * c)  # 移动到该半边的鱼眼的圆上 R/3*c 表示移动到哪边
    turtle.pendown()  # 放下画笔，移动留痕
    turtle.fillcolor(TJT_color.get(-c))  # 获取鱼眼填充色, 与该半边相反
    turtle.begin_fill()
    turtle.circle(-R / 6, 360)
    turtle.end_fill()

    # 回到原点，为下一循环的开始做准备
    turtle.penup()
    turtle.goto(0, 0)
    turtle.pendown()
~~~





### 6.4.4 第三方库

第三方使用语言提供的库

网络爬虫

~~~python
requests scrapy
~~~

数据处理

~~~python
numpy scipy pandas
~~~

文本处理

~~~python
pdfminer openpyxl python-docx beautifulsoul
~~~

数据可视化

~~~python
matplotlib TVTK mayavi
~~~

用户图形界面

~~~python
PyQt5 wxPython PyGTK
~~~

机器学习

~~~python
Theano TensorFlow scikiy-learn
~~~

Web 开发

~~~python
Django Pyramid Flask
~~~

游戏开发

~~~python
Pygame Panda3d cocos2d
~~~

更多第三方库

~~~python
PIL SymPy NLTK WeRoBot MYQR
~~~

#### 第三方安装

安装包管理工具

~~~python
pip install <拟安装命令>
~~~

![image-20210625103950608](https://resource-joker.oss-cn-beijing.aliyuncs.com/picture/image-20210625103950608.png)

查看自己之前安装过哪些库

~~~python
pip list
~~~



源文件安装