Python学习周报

Python

pycharm一些快捷键

Ctrl+f搜索

ctrl+d复制当前一行
shift+alt +上下键移动

Ctrl+alt+l 自动空格

Ctrl+/ 注释

Ctrl+p 查看可用函数

字面量

数字 小数可以直接被输出，不需要变成字符串或者变量。

Print(666)

Print(13.1415)

Print("ni hao")

单行注释（最好加空格）

# 发反对反对反对

多行注释

"""

OK

你是对的

 

"""

变量

无需；结束

直接等于

print（money）直接输出

数据类型

• type（）

• string

• int

• float

数据类型转换，例如：

​ int(x)

​ float(x)

要注意：

• 在类型转化时会丢失精度
• 任何数据类型都可以转化成字符串

常见函数：

int(x [,base]) 将x转换为一个整数
long(x [,base]) 将x转换为一个长整数
float(x) 将x转换到一个浮点数
complex(real [,imag]) 创建一个复数
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
chr(x) 将一个整数转换为一个字符
unichr(x) 将一个整数转换为Unicode字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串

变量声明：

• 变量不用声明
• 不可数字开头，仅支持字母数字下划线

运算符:

// 取整除

** 取指数

复合赋值运算符:

+=

-=

/=

*=

字符串:

' '

" "

“”" “”" 如果有变量接受就是字符串

\解引用 " " "

字符串拼接:

用+号

**注意：**字符串，整数用逗号

字符串格式化，占位符号 与c相同

%s

Mes="ABS%s" %Mes(多个用括号，直接加逗号)

会直接将数字变成字符串

其他与c相同 %d %f

字符串格式化精度控制:

%5d 补齐到5位（如果偏小不做限制）

%5.2f 将宽度控制为5，小数点控制为2

字符串格式化方式2:

print(f" I'm your father {age},wait a min")

不换强制转化，精度不会发生变化

对表达式进行格式化:

表达式可以直接套入，格式化

数据输入：

Input()

获得的永远是字符串类型

括号里可以直接输出字符串，例如:input("请输入")

布尔类型：

True 1

False 0

如果直接比较，变量会变成布尔类型

Result=10>5=ture

Result="it"=="I" = false

简单语句

判断语句:

If 检测其属于代码利用缩进而不是大括号

在其后加上冒号，例如：

If a>b:

If else语句

两者都需要冒号：

多选择判断

If :

Elif:

Elif:

Elif:

Else:

• elif和if 同级，不用缩进

• 当任意一个elif或if语句成功就会跳出，并执行else

附加：

随机数实现：

import random

Num = random.randint(1,10)

循环语句

案例：

i=0 

While i<100:

Print()

i+=1

While 嵌套

"End=''可以使得print不换行**

\t 使得其对齐

For 循环基本语法：

遍历字符串：

Name="itheima"

For x in name:

Print(x) 

注意：会将字符串拆开给x接受

range语句:

语法一：

Range(num)

获取一个从0开始到num结束的数字序列（不包含其本身）

语法二：

Range(num1,num2)

从num1开始到num2，不包含num2

语法三：

Range(num1,num2,step)

从num1到num2的等差数列

step为公差

与for联系：

For x in range(10):

For x in range (5,10):

For x in range(5,10,2):

x 每次赋值都会按照语法要求依次赋值

循环中断： break和continue

• continue直接进行到下次循环，无需冒号
• break结束循环，无需冒号

上述两个都只作用于当前循环

• pass为空语句，作占位语句，不做任何事情

python数字函数

函数定义：

def 函数名(传入参数):

函数体:

Return 返回值

定义为形式参数

调用为实际参数

无返回值等于返回None

返回空等于False

可以对函数书写说明文档:

**实现：**加入"""批注即可

:param x：对x的说明

：return 对返回值的说明

函数嵌套

在函数中调用另一个函数

def nihao
	pass
def you()
	def nihao()  

global全局变量

将函数内部i的局部变量变成全局变量

语法：global a=c

数据容器

list（列表）

tuple（元组）

str（字符串）

set（集合）

dict（字典）

列表（list)

基本语法：

#字面量

[元素1，元素2，元素3，元素4，..]

 

#定义变量

变量名称=[元素1，元素2，元素3，元素4，·.]

 

#定义空列表

变量名称=[]

变量名称=list()

列表内的每一个数据，称之为元素

• 以[]作为标识
• 列表内每一个元素之间用，逗号隔开

嵌套列表:

list=[[1,2,3],[4，5，6]]

列表的下标索引 :

• 列表索引可以正向也可以反向，可以负数

• 嵌套列表等于二元数组

从前向后，从0开始，每次+1

从后向前，从-1喀什，每次-1

方法：

比喻list为一个类，其有成员成员函数

先实例化列表，再使用其函数

语法：数组.index

• index方法 查找其位置，如果不存在就报错（元素） ->输出下表索引
• insert方法 再指定的下标位置，插入指定的元素（下表索引，元素）
• append方法 追加指定的元素位于列表尾部（元素）
• extend方法 将其他列表追加到列表尾部（列表）

删除方法:

• del方法 删除指定下标对应元素（下标索引）
• pop方法 将列表中元素取出，返回该元素，可以用变量接收（下标索引） 返回元素
• remove 移除从头开始搜索的第一个与传入元素相同的元素，并进行删除（元素）
• clear 删除列表（空）

统计方法:

• count 统计列表中的传入元素的数量（元素） 返回数量

• len 统计全部元素的数量 返回数量

循环遍历列表:

Index=0

While index<len(列表):

元素 = 列表[index]

# 对元素进行处理

Index += 1

元组

使用小括号

(元素，元素…..)

定义空元组:

变量名称=()

变量名称j=tuple()

定义单个元素要在元素后面加上单独的逗号(tuple,)

• 元组同样可以嵌套

• 元组有同样的下标索引

方法：

• index() 查找对应元素的下标索引 有返回值
• count() 统计对应元素的数量 有返回值
• len() 统计元素的数量

特点：元组只可读，但嵌套list之后可以修改

字符串

“你好abc”

• 字符串本身也是容器，有其下标索引

• 字符串也是只读，不可修改的、

方法:

index（字符串）

replace （字符串，字符串）字符串替换，获得一个新的字符串

split 按照指定的分隔符分割字符串，分成多个元素，并获得一个新的字符串

strip() 不传入参数，去除首位空格

传入参数后，取出所有含有的字符串，作用于首尾

Count() 同上

Len() 统计字符串长度

特点：只读 长度任意 支持for循环

序列

序列的切片

语法:

序列[起始下标:结束下标:步长]

表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

• 起始下标表示从何处开始，可以留空，留空视作从头开始
• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾

• 步长表示，依次取元素的间隔

  • 步长1表示，一个个取元素

  • 步长2表示，每次跳过1个元素取

  • 步长N表示，每次跳过N-1个元素取

  • 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

注意，切片时会产生新的序列

---

集合(set)

定义集合 set = {元素，元素，元素....}

定义空集合 my_set = set()

定义非空集合 my_set=set(list)

• 集合内元素不重复，内容无序，不支持下标访问
• 可修改

方法：

1. add 添加指定元素
2. remove 去除指定元素
3. pop 随机取元素
4. clear 清空集合
5. difference 取出两个集合的差集（集合一有而集合二没有）
6. difference_update 消除差集（消除集合1中两级和共有的）
7. union 合并两个集合
8. len 计算集合长度

遍历：

​ 不可使用while

for element in set1:

---

字典(dict)

通过key，找到对应的value

定义字典字面量
{key:value,key:vale,......key:value}
定义字典变量
my_dict {key:value,key:value,......,key:value}
定义空字典
my_dict = {}
my_dict = dict()

字典中，Key不可以重复，否则会被新的覆盖

从字典中同过key获取value

score = dict1["对应元素"]

key和value不受限（但key不能为字典）

操作：

字典的嵌套：dict1={'小明':{"语文":100,"数学":100}}

获取嵌套字典信息：socre = dict1{"小明"}{"语文"}

• 新增元素

  • 语法：dict[key] = value 结果：字典被修改，新增元素

• 更新元素

  • 语法：dict[key] = value 结果：字典被修改，更新元素
  • 注意：字典Key不可以重复，所以对已存在的Key操作就是更新

  方法:

  1. pop 取出value并删除字典中的value
  2. clear 清空
  3. keys 得到全部Key
  4. len 统计元素数量

  遍历字典：

  方式一：

  dict1={'小明':{"语文":100,"数学":100}}
  keys = dict1.keys()
  	for key in keys:
  

  方式二：

  ​ for key in dict1

  方式三：

  ​ 将Key存入列表，再用while遍历

  ---

总结

1. 基于各类数据容器的特点，它们的应用场景如下：

• 列表：一批数据，可修改、可重复的存储场景
• 元组：一批数据，不可修改、可重复的存储场景
• 字符串：一串字符串的存储场景
• 集合：一批数据，去重存储场景
• 字典：一批数据，可用Key检索Value的存储场景

#### 通用操作

1. len

2. clear

3. max 查找最大元素 字符串比较ASCII码大小（一位一位相比较，如果一个大既比较完成）

4. min查找最小的元素

5. for循环遍历

   类型转化：

   • list() 列表

   • str() 字符串

   • tuple() 元组

   • set() 集合

     转列表：

     • 字符串会拆开每一个字符
     • 字典只会提取key

     **转元组：**同上

     转字符串：

     会变成整体，字典会全部保存

     转集合：

     • 数据无序
     • 去重

   注意：转字典无法实现，因为其为键指对形式，无法转化

​ 通用排序：

• sorted(容器) 容器正向排序（从小到大）

• sorted(容器,[reverse=True]) 容器反向排序（从大到小）

排序结果会变成列表对象

---

函数进阶

函数的多返回值

多个返回值不可用多个return，应该用return 1,2多返回，数据不限制

• 用一个变量接受就是tuple
• 多个变量按顺序接受

函数的多种传参方式

1. 关键字参数：

   函数调用时通过“键=值”形式传递参数
   作用：可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求

• def user_info(name,age,gender)
  print(f"您的名字是：{name},年龄是：{age},性别是：{gender")
  
  * 关键字传参
    user_info(name="小明"，age=20,gender:="男")
  * 可以不按照固定顺序
    user_info(age=20,gender-="男"，name="小明")
  * 可以和位置参数混用，位置参数必须在前，且匹配参数顺序
    user_info("小明"，age=20,gender="男")
  

2. 缺省参数：

   缺省参数：缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：
   所有位置参数必须出现在默认参数前，包括函数定义和调用)，
   **作用：**当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值

   def user_.info(name,age,gender='男')：
   print(f'您的名字是{name},年龄是{age},性别是{gender}')
   user_info('TOM',20)
   user_info('Rose',18,')
   

   注意：

   • 函数调用时，如果为缺省参数传值则修改默认参数值，否则使用这个默认值,也就是传入即覆盖
   • 默认参数必须在最后定义（存疑）

3. 位置传递

   def user info(*args):
   print(args)
   #（TOM',)
   user_info('TOM')
   #(T0M',18)
   user_info('TOM',18)
   

   注意：

   • 传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple),args是元组类型，这就是位置传递
   • 位置传递不定长

4. 关键字传递

   def user_info(**kwargs):
   	print(kwargs)
       
   #{'name':T0M','age':18,'id':110}
   user_info(name='TOM',age=18,id=110)
   

   注意：
   参数是“键=值”形式的形式的情况下，所有的“键=值”都会被kwargs接受，同时会根据“键=值”组成字典.

函数作为参数传递

如下代码：

def test_func(compute):
	result compute(1,2)
	print(result)
def compute(x,y):
	return x y

test_func(compute)   #结果：3

函数compute,作为参数，传入了test func函数中使用。

• test_func需要一个函数作为参数传入，这个函数需要接收2个数字进行计算，计算逻辑由这个被传入函数决定
• compute函数接收2个数字对其进行计算，compute函数作为参数，传递给了test_func函数使用
• 最终，在test_func函数内部，由传入的compute函数，完成了对数字的计算操作

所以，这是一种计算逻辑的传递，而非数据的传递。
就像上述代码那样，不仅仅是相加，相见、相除、等任何逻辑都可以自行定义并作为函数传入。

lambda匿名函数

函数的定义中

• def关键字，可以定义带有名称的函数
• lambda关键字，可以定义匿名函数（无名称）
  有名称的函数，可以基于名称重复使用。
  无名称的匿名函数，只可临时使用一次。

匿名函数定义语法：
lambda传入参数：函数体（一行代码）

• lambda是关键字，表示定义匿名函数

• 传入参数表示匿名函数的形式参数，如：X,y表示接收2个形式参

• 函数体，就是函数的执行逻辑，要注意：只能写一行，无法写多行代码

如下图代码，我们可以：

• 通过def关键字，定义一个函数，并传入，如下图：

  def test_func(compute):
  	result compute(1,2)
  	print(result)
  def compute(x,y):
  	return x y
  
  test_func(compute) #结果：3
  

• 也可以通过lambda关键字，传入一个一次性使用的lambda匿名函数

  def test_func(compute):
  	result compute(1,2)
  	print(result)
  test_func(lambda x,y:x y)  #结果：3
  

  使用def和使用lambda,定义的函数功能完全一致，只是lambda关键字定义的函数是匿名的，无法二次使用

---

Python的文件操作

文件的编码

编码技术即：翻译的规则，记录了如何将内容翻译成二进制，以及如何将二进制翻译回可识别内容

计算机中有许多可用编码：

• UTF-8(最通用的编码)
• GBK
• Big5
  …

不同的编码，将内容翻译成二进制也是不同的。

文件的读取

open()打开函数

在Python,.使用open函数，可以打开一个已经存在的文件，或者创建一个新文件，语法如下
open(name,mode,encoding)
name:是要打开的目标文件名的字符串（可以包含文件所在的具体路径）。
mode:设置打开文件的模式（访问模式）：只读、写入、追加等。
encoding:编码格式（推荐使用UTF-8)
示例代码：
f open('python.txt','r',encoding="UTF-8)
encoding的顺序不是第三位，所以不能用位置参数，用关键字参数直接指定
注意事项:
此时的f是open函数的文件对象，对象是Python中一种特殊的数据类型，拥有属性和方法，可以使用对象.属性
或对象.方法对其进行访问。

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，原有内容会被删除。 如果该文件不存在，创建新文件。
a	订开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后。 如果该文件不存在，创建新文件进行写入。

读操作方法

​ read()方法：
​ 文件对象.read(num)
​ num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据。

• tips：read()在使用后，会在上一次read之后进行读取，包括下面的readlines函数

​ readlines方法：
​ readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个
​ 元素。

f open('python.txt')
	content = f.readlines()
# ['hello world\n','abcdefg\n','aaa\n','bbb\n','ccc']
print(content)
#关闭文件
f.close()

readline方法：

​ 一次只读取一行

for 循环读取文件行：

for lin in f:
    print(f"每一行的数据是:{line}")

文件关闭：

​ close()解除占用

​ time.sleep(num)可以实现num秒的运行

with open()as f 语法

with open("python.txt","r")as f:
	f.readlines()
#通过在with open的语句块中对文件进行操作
#可以在操作完成后自动关闭close文件，避免遗忘掉close方法

f:下面只能进行文件操作

文件的读写操作

#1.打开文件
f open('python.txt','w')
#2.文件写入
fwrite(hello world')
#3.内容刷新
f.flush() # 刷新后才会写入硬盘 

注意：

• 直接调用write内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区

• 当调用f1ush的时候，内容会真正写入文件

• 这样做是避免频繁的操作硬盘，导致效率下降（攒一堆，一次性写磁盘）

• 文件位置最好使用/或者\才能读取，有可能转义字符和文件名发生联动

• close()包括flush功能。

• 文件不存在会生成文件，文件已经存在会清空内容后写入

文件的追加

案例演示：

#1.打开文件，通过a模式打开即可
f = open('python.txt',"a')
#2.文件写入
f.write('hello world')
#3.内容刷新
f.flush()

注意：

• a模式，文件不存在会创建文件
• a模式，文件存在会在最后，追加写入文件
• 用换行符\n进行输入

Python异常、模块与包

了解异常

bug（小虫子）

软件出错

异常的捕获方法

体现准备可能发生异常的代码

基本语法：

try:
    # 可能发生错误的代码
except:
    # 如果出现异常执行的代码（补救代码）

捕获指定的异常：

try:
    print（name）
except NameError as e:
    print(e)

e中会捕获异常的原因，print(e)可以将报错原因直接打印出来

捕获多个异常：

try:
    1/0
    print(name)
except (NameError,ZeroDivisionError) as e:

捕获所有的异常：

try:
except Exception as e:
    print("有异常")
# 基本语法也可以实现

else和finally语法：

try:
    print("你好") 
except Exception as e:
    print("有异常")
else:# 没有异常时候运行
    print("没有异常")
finally:
    f.close() # 无论如何都会运行

else: 没有异常时候运行

finally:无论如何都会运行

异常的传递性

def func01():# 异常在funco1中没有被捕获
print("这是func01开始")
	num = 1 / 0
	print("这是func01结束")
# 异常在func02中没有被捕获
def func02():
	print("这是func02开始")
	func01()
	print("这是func02结束")
def main():# 异常在mian中被捕获
	try:
		func02()
	except Exception as e:
		print(e)

当函数func01中发生异常，并且没有捕获处理这个异常的时候，异常会传递到函数func02,当func02也没有捕获处理这个异常的时候main函数会捕获这个异常，这就是异常的传递性

​ 提示：
当所有函数都没有捕获异常的时候，程序就会报错

异常综合案例

Python模块

模块介绍

什么是模块？
Python模块(Modul)，，是一个Python文件，以.py结尾.

模块能定义函数，类和变量，模块里也能包含可执行的代码

模块的作用：

python中有很多各种不同的模块，每一个模块都可以帮助我们快速的实现一些功能，比如实现和时间相关的功能就可以使用time模块我们可以认为一个模块就是一个工具包，每一个工具包中都有各种不同的工具供我们使用进而实现各种不同的功能

大白话：

模块就是一个Python文件，里面有类、函数、变量等，我们可以
拿过来用（导入模块去使用）

模块的导入方式：[from 模块名] import [模块|类|变量|函数|*][as 别名]（*代表全部内容）

常用的组合形式如：

• import 模块名
• from 模块名 import 类、变量、方法等
• from 模块名 import *
• import 模块名 as 别名
• from 模块名 import 功能名 as 别名

import模块名

​ 基本语法：

import模块名
import模块名1，模块名2
模块名功能名()

​ 案例：导入time模块

#导入时间模块
import time

print("开始")
#让程序睡眠1秒（阻塞）
time.sleep(1)
print("结束")

from模块名 import 功能名

​ 基本语法：

from 模块名 import 功能名
功能名()

​ 案例：导入time模块中的sleep方法

#导入时间模块中的sleep方法
from time import sleep
print("开始")
#让程序睡眠1秒（阻塞）
sleep(1)
print("结束")

**from 模块名 import ***
基本语法：

from 模块名 import *
功能名()

​ 案例：导入time模块中所有的方法

#导入时间模块中所有的方法
from time import *
print("开始")
#让程序睡眠1秒（阻塞）
sleep(1)
print("结束")

可以直接写sleep，不用再写.

as定义别名

基本语法：

#模块定义别名
import 模块名 as 别名
#功能定义别名
from 模块名 import 功能 as 别名

案例：

#模块别名
import time as tt
tt.sleep(2)
print('hello')
#功能别名
from time import sleep as sl
sl(2)
print("hello')

自定义模块

新建一个Python文件，在其中写入函数，就可以在其他文件时引用使用了

注意事项：

#模块1代码
def my_test(a,b):
print(a b)

#模块2代码
def my_test(a,b):
print(a b)

#导入模块和调用功能代码
from my_modulel import my_test
from my_module2 import my_test

#my_test函数是模块2中的函数
my_test(1,1)

​ 当导入多个模块的时候，且模块内有同名功能，当调用这个同名功能的时候，调用到的是后面导入的模块的功能

测试模块

在实际开发中，当一个开发人员编写完一个模块后，为了让模块能够在项目中达到想要的效果，
这个开发人员会自行在py文件中添加一些测试信息，例如，在my module1.py文件中添加测试代码test(1,1)

def test(a,b):
print(a b)
test(1,1)

问题：

此时，无论是当前文件，还是其他己经导入了该模块的文件，在运行的时候都会自动执行test函数的调用

解决方案：

在要测试的语句上方打出main，会自动写入一串代码，如下：

def test(a,b):
print(a b)

if __name__=='__main__':
	test(1,1)

运行时会检测其是否为main，外部用from导入时就不会运行

也就是，只有内部可运行，外部不运行。

__all__

如果一个模块文件中有__all__变量，当使用from xxx import *为导入时，只能导入这个列表中的元素

如果不写__all__语法，就默认导入所有函数

Python包

Python包介绍

模块为文件，包就为文件夹

只要拥有__init__.py的文件在文件夹中，就属于包

使用:

import my_package.my_module1
my_package.my_module1.print1()

或者：

from my_package.my_module1 import print1()
print1()

在__init__.py文件中可以使用__all__=[“文件名”]函数控制import *号范围

安装第三方Python包

​ 我们知道，包可以包含一堆的Python模块，而每个模块又内含许多的功能。所以，我们可以认为：一个包，就是一堆同类型功能的集合体。在Python程序的生态中，有许多非常多的第三方包（非Python官方），可以极大的帮助我们提高开发效率，如：

• 科学计算中常用的：numpy包
• 数据分析中常用的：pandas包
• 大数据计算中常用的：pyspark、apache-flink包
• 图形可视化常用的：matplotlib、pyecharts
• 人工智能常用的：tensorflow
  等

​ 第三方包Python没有内置，需要自己手动安装

​ 安装第三方包 pip
​ 第三方包的安装非常简单，我们只需要使用Python内置的pip程序即可。
打开命令提示符程序，在里面输入：
pip install 包名称
即可通过网络快速安装第三方包

数据可视化

echarts技术

使用pyecharts包可视化数据

Jison

• JSON是一种轻量级的数据交互格式。可以按照JSON指定的格式去组织和封装数据

• JSON本质上是一个带有特定格式的字符串

• JSON还有可能为内部元素都为字典的列表

  主要功能：jso就是一种在各个编程语言中流通的数据格式，负责不同编程语言中的数据传 递和交互.类似于：

  • 国际通用语言-英语
  • 中国56个民族不同地区的通用语言-普通话

各种编程语言存储数据的容器不尽相同，在Python中有字典dict这样的数据类型，而其它语言可能没有对应的字典。
为了让不同的语言都能够相互通用的互相传递数据，JSON就是一种非常良好的中转数据格式。如下图，以Python和C语
言互传数据为例：

json格式数据转化
json格式的数据要求很严格

#json数据的格式可以是：
{"name":"admin","age":18}
#也可以是：
[{"name":"admin","age":18},{"name":"root","age":16},{"name":"=","age":20}]

Python 数据和 Json 数据的相互转化(方法)

#导入json模块
import json

#准备符合格式json格式要求的oython数据
data=[{"name":"老王"，"age":16},{"name":"张三"，"age":20}]

#通过json.dumps(data)方法把oython数据转化为了json数据
data=json.dumps(data)

#通过json.loads(data)方法把json数据转化为了python数据
data=json.loads(data)

如果中文显示出错，可以使用

jaso.dumps(date,ensure_ascii=False)使其不为ASCII码输出

• 通过json.loads转化的数据会变成list形式
• 同理，可以将字典形式的字符串转化为字典，如"{"name":"周杰伦","addr":"台北"}"

pyecharts模块

​ 概况：
Echarts是个由百度开源的数据可视化，凭借着良好的交互性，精巧的图表设计，得到了众多开发者的认可。而Python是门富有表达力的语言，很适合用于数据处理。当数据分析遇上数据可视化时oyecharts诞生了。

查询网站：pyecharts - A Python Echarts Plotting Library built with love.

图库：中文简介 - Document (pyecharts.org)

pyecharts入门

​ 基础折线图

#导包，导入Line功能构建折线图对象
from pyecharts.charts import Line
#得到折线图对象
line=Line()
#添加X轴数据
1ine.add_xaxis(["中国"，"美国"，"英国"])
#添加y轴数据
line.add_yaxis("GDP",[30,20 ,10])
#生成图表
line.render()

pyecharts模块中有很多的配置选项，常用到2个类别的选项：

• 全局配置选项
• 系列配置选项

set_global_opts方法

1. 配置案例

   from pyecharts.options import TitleOpts,LegendOpts,toolboxopts # 导入包
   line.set_global_opts(
   	title_opts=TitleOpts("GDP展示",pos_left="center",pos_bottem="1%"),# 标题位于中心，底部1%处
   	legend_opts=LegendOpts(is_show=True),# 图例显示
   	toolbox_opt=ToolboxOpts(is_show=True),# 工具箱
       visualmap_opts=VisualMapOpts(is_show=True)，# 视觉映射 
   )
   # 也可title_opts=TitleOpts(title="GDP展示"))
   

具体可查询网站pyecharts.org

面向对象

与c++相似

class Student:
    name = None
    gender = None
    nationality = None
    native_place = None
    age = None


stu_1 = Student()
stu_1.name = "林俊杰"
stu_1.gender = "男"
stu_1.nationality = "中国"
stu_1.native_place = "山东省"
stu_1.age = 31

类的定义和使用

定义：

class 类名:
	成员 = None
# 使用
变量 = 类名()

在类中可以定义函数，此时函数会成为类的成员函数，也叫方法。

使用：类名.方法名

成员方法的定义语法

在类中定义成员方法和定义函数基本一致，但仍有细微区别：
def方法名(se1f,形参1，......，形参N): 方法体
可以看到，在方法定义的参数列表中，有一个：self关键字
self关键字是成员方法定义的时候，必须填写的。

• 它用来表示类对象自身的意思
• 当我们使用类对象调用方法的是，self会自动被python传入
• 在方法内部，想要访问类的成员变量，必须使用self，例如self.name

类和对象

设计类，基于类创建对象做具体的工作

winsound.beep(2000,3000)

属性（成员变量）的赋值

​ 构造方法：

Python类可以使用:__init__ 方法，称之为构造方法。
可以实现：
在创建类对象（构造类）的时候，会自动执行。
在创建类对象（构造类)的时候，将传入参数自动传递给iit方法使用。

class Student:
    name = None
    age = None
    tel = None
    
    def __init__(self,name,age,tel):
    	self.name = name
    	self.age = age
    	self.tel = tel
    	print("Stuendt类创建了一个对象")
 
 stu = Student("周杰轮",31,"18500006666")

​ 上面对象的三次声明可以省略，在下方会自动声明

魔术方法

__str__字符串方法

class Student:
    def __init__(self,name,age)：
    self.name = name
    self.age = age
 
student = Student("周杰伦",11)
print(student)# <main.student object at 0x000002200cFD7040>
print(str(student)) # <main_.student object at 0x000002200CFD7040>

当类对象需要被转换为字符串之时，会输出为当前地址

内存地址没有多大作用，我们可以通过__str__方法，控制类转化为字符串的行为

class Student:
    def __str__(self):
        return f"Student类对象，name={self.name},age={self.age}"
    
print(student) # 结果：Student类对象，name={周杰伦},age={11}
print(str(student)) # 结果：Student类对象，name={周杰伦},age={11}

__lt__小于符号比较方法

class student:
	def _init_(self,name,age):
		self.namename
		self.age age
stu1=Student("周杰轮"，11)
stu2=student("林军杰"，13)
print(stul < stu2)

使用后：

class student:
	def _init_(self,name,age):
		self.namename
		self.ageage
def _lt_(self,other):
	return self.age < other.age

stu1=Student("周杰轮"，11)
stu2=Student("林军杰"，13)
print(stu1 < stu2)#结果：True
print(stu1 > stu2)#结果：Falue

__le__大于等于语言符号比较方法

def __le__(self,other):
    return self.age <= other.age

__eq__比较运算符实现方法

class student:
	def _init_(self,name,age):
	self.name name
	self.age age # 方法名：_q_
def _eq_(self,other): # 传入参数：ther,另一个类对象
return self.age = other.age # 返回值：True或False
stu1 = student("周杰轮"，11) # 内容：自行定义
stu2 = Student("林军杰"，11)
print(stu1l = stu2)#结果：True

如果不使用__eq__魔术方法，==会比较地址是否相等

封装

私有成员
既然现实事物有不公开的属性和行为，那么作为现实事物在程序中映射的类，也应该支持。

定义私有成员：

• 私有成员变量：变量名以__开头(2个下划线)
• 私有成员方法：方法名以__开头（2个下划线)

即可完成私有成员的设置

同C++，私有成员无法被类外对象使用

但可被类内对象使用

继承

继承过去的类的对象以及方法。

比如存在

class Phone:
    id=1
    producer=iphone
    
    def call(self):
        print("123")

再使用class Phone1(Phone):即可继承

继承分为单 继承和多继承

单继承语法为：

class 类名（父亲名）:

多继承语法为：

class 类名(父类名,父类名....)

注意：

• 父类成员名 一样的话，优先左边父类，先继承的优先级高于继承的
• 继承无内容加个pass占位语句，表示空

复写：

子类继承父类的成员属性和成员方法后，如果对其“不满意”，那么可以进行复写。
即：在子类中重新定义同名的属性或方法即可。

class Phone:
	IMEI=None # 序列号
	producer="ITCAST"# 厂商
    
	def call_by_5g(self):
		print("父类的5g通话")
class MyPhone(Phone):
	proucer "ITHEIMA" # 复写父类属性
	def call_by_5g(self):# 复写父类方法
		print("子类的5g通话")

如果直接使用复用成员，会调用子类成员

调用父类同名成员：

如果需要使用被复写的父类的成员，需要特殊的调用方式：
方式1：

• 调用父类成员
  使用成员变量：父类名.成员变量
  使用成员方法：父类名.成员方法(self)
  方式2：
• 使用super()调用父类成员
  使用成员变量：super().成员变量
  使用成员方法：super().成员方法()

多个父类时，使用super优先调用最左的父类