文章目录
语法基础
判断
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

提示：这里可以添加本文要记录的大概内容：
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、pandas是什么？

示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。

二、使用步骤

1.引入库

代码如下（示例）：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
import  ssl
ssl._create_default_https_context = ssl._create_unverified_context

2.读入数据

代码如下（示例）：

data = pd.read_csv('https://labfile.oss.aliyuncs.com/courses/1283/adult.data.csv')
print(data.head())

该处使用的url网络请求的数据。

---

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
字符类型
整形 int
长整型 long
浮点型 float
复数 complex
布尔型 bool
字符串 str
列表 List
元组 Tuple
字典 Dictionary
标识符
由字母，下划线和数字组成，且数字不能开头
区分大小写
关键词
特殊功能的标识符
‘False’, ‘None’, ‘True’, ‘peg_parser’, ‘and’, ‘as’, ‘assert’, ‘async’, ‘await’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘nonlocal’, ‘not’, ‘or’, ‘pass’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’

输出
格式化输出
格式化常用符号
%s 格式化字符串
%d 格式化整数
%-2d 显示两位并左对齐，若只有一位则用空格占位，默认右对齐
%f 格式化浮点数字，可指定小数点后的精度
myAge = 20
print(“我的年龄是%d岁” % myAge)

转义输出
常用转义字符
\n 换行符
\t 横向制表符（TAB）
\0 表示一个空字符
\v 纵向制表符
\r 回车符
\f 换页符
输入
input得到的结果是String

myName = input("please enter your Name:")
myAge = input("please enter your Age:")
print("Name:%s Age:%s" % (myName,myAge))

运算符

算术运算符

• 加；- 减；* 乘；/ 除；// 整除；% 取余；** 指数
  赋值运算符 =
  复合赋值运算符
  算术运算符复合赋值运算符
  关系运算符
  ==；!=；>；<；>=；<=
  逻辑运算符
  and；or；not
  常用数据类型转换

int(x) 将x转换为一个整数
float(x) 将x转换为一个浮点数
str(x) 将x转换为一个字符串
eval(str) 用来计算在字符串中的有效python表达式，并返回一个对象

判断语句和循环语句
if-elif-else
if 判断条件1:
执行语句1
elif 判断条件2:
执行语句2
else：
执行语句3

if嵌套（采用缩进区分层次）

> money = eval(input("请输入您公交卡的余额:")) flag = not True if money >= 2:
>     print("可以上公交车")
>     if flag:
>         print("可以坐下")
>     else:
>         print("站一会") else:
>     print("请充值后再上车")

while循环
while 判断条件:
执行语句
循环标识+1

while循环嵌套
#九九乘法表

x = 1
while x <= 9:# 定义一个变量 记录列数y = 1while y <= x:print("%d * %d = %-2d" % (y, x, x * y), end="  ")y += 1# 换行print()x += 1

for循环
范围函数range()
range(m,n) -> [m,n)
range(n) -> [0,n)
for 临时变量 in 可迭代对象（列表/字符串/…）:
执行语句

break&continue
break：结束所有循环
continue：提前结束本次循环，进入下一次循环

for-else&while-else
for i in range(5):print(i)if i == 2:#breakelse:print("else")

while循环

i = 0
while i < 5:print(i)if i == 2:breaki += 1
else:print("else")

“”"
无论for-else 还是 while-else 如果在for循环中 或者 while循环中 没有执行break 待for循环或者while结束后 会执行else中的代码
当for循环或者while循环中的break执行 else中的代码将不会执行
“”"

字符串
字符串 -> 有序的字符序列
索引
从左到右0,1,2…
从右到左-1,-2,-3…
切片 [start,end,step] 范围[start,end)
常见操作
len(str) 获取字符串长度
mystr = “”“文本内容”"" 保留拷贝的文本格式
mystr.find(“str”) 获取对应字符串的下标索引，如果未查询到，返回-1；
mystr.index(“str”) 获取对应字符串的下标索引，如果未查询到，返回异常；
mystr.count(str,start=0,end=len(myStr)) 返回str在start和end之间在mystr中出现的次数；
mystr.replace(str1,str2,n) 把myStr中的str1替换成str2；如果n指定，则不超过n次；
mystr.split(str=" ",2) 以str为分隔符，切片mystr，返回一个列表；如果n指定，则仅分隔n个字符串；
mystr.capitalize() 把字符串的第一个字符大写；
mystr.title() 把字符串的每个单词首字母大写；
mystr.startswith(obj)检查字符串是否是以 obj开头, 是则返回 True，否则返回 False；
mystr.endswith(obj) 检查字符串是否以obj结束，如果是返回True,否则返回 False；
mystr.lower() 转换字符串中所有大写字符为小写；
mystr.upper() 转换字符串中的小写字母为大写；
mystr.ljust(width,fillchar) 返回一个原字符串左对齐,并使用指定fillchar[默认空格]填充至长度 width 的新字符串
mystr.rjust(width,fillchar) 返回一个原字符串右对齐,并使用指定fillchar[默认空格]填充至长度 width 的新字符串
mystr.center(width,fillchar) 返回一个原字符串居中,并使用指定fillchar[默认空格]填充至长度 width 的新字符串
mystr.lstrip() 删除 mystr 左边的空白字符
mystr.rstrip() 删除 mystr 字符串末尾的空白字符
mystr.strip() 删除mystr字符串两端的空白字符
mystr.rfind(str, start=0,end=len(mystr) ) 类似于find()，不过是从右边开始.
mystr.rindex( str, start=0,end=len(mystr)) 类似于 index()，不过是从右边开始
mystr.partition(str) 把mystr以str分割成三部分,str前，str和str后
mystr.rpartition(str) 类似于 partition()函数,不过是从右边开始.
mystr.splitlines() 按照行分隔，返回一个包含各行作为元素的列表
mystr.isalpha() 如果 mystr 所有字符都是字母 则返回 True,否则返回 False
mystr.isdigit() 如果 mystr 只包含数字则返回 True 否则返回 False.
mystr.isalnum() 如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False
mystr.isspace() 如果 mystr 中只包含空格，则返回 True，否则返回 False.
mystr.join(str) mystr中每个元素后面插入str,构造出一个新的字符串

列表
定义
my_list =[元素1，元素2，…]
索引
从左到右0,1,2…
从右到左-1,-2,-3…
列表的循环遍历
for循环
while循环

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
for name in namesList:print(name)length = len(namesList)
i = 0
while i<length:print(namesList[i])i+=1

常见操作
添加元素
append
添加一个整体
extend
添加一个可以遍历的对象；将另一个集合中的元素逐一添加到列表中
insert(index, object)
在指定位置index前插入元素object

```bash
>>> a = [1, 2]
>>> b = [3, 4]
>>> a.append(b)
>>> a
[1, 2, [3, 4]]>>> a.extend(b)
>>> a
[1, 2, [3, 4], 3, 4]
``
>>> a.insert(1, 3)
>>> a
[1, 3, 2, [3, 4], 3, 4]

修改元素
A = [‘xiaoWang’,‘xiaoZhang’,‘xiaoHua’]

#修改元素
A[1] = ‘xiaoLu’

查找元素

in, not in
nameList = ['xiaoWang','xiaoZhang','xiaoHua']findName = input('请输入要查找的姓名:')#查找是否存在
if findName in nameList:print('找到了')
else:print('没有找到')

index
返回查找元素的下标索引

>>> a = ['a', 'b', 'c', 'a', 'b']
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):File "<stdin>", line 1, in <module>
ValueError: 'a' is not in list
>>> a.index('a', 1, 4)
3>>> a.count('b')
2
>>> a.count('d')

删除元素
del
根据下标进行删除
可以用来删除对象，提前释放内存
pop
删除最后一个元素，且会有一个返回值
remove
根据元素的值进行删除
movieName = [‘加勒比海盗’,‘骇客帝国’,‘第一滴血’,‘指环王’,‘霍比特人’,‘速度与激情’]

del movieName[2] #根据下标进行删除

movieName.pop() #删除最后一个元素

movieName.remove(‘指环王’) #根据元素的值进行删除

排序
sort，reverse

>>> a = [1, 4, 2, 3]
>>> a
[1, 4, 2, 3]
>>> a.reverse() #降序
>>> a
[3, 2, 4, 1]
>>> a.sort()
>>> a
[1, 2, 3, 4]
>>> a.sort(reverse=True)
>>> a
[4, 3, 2, 1]

列表的嵌套

schoolNames = [['北京大学','清华大学'],['南开大学','天津大学','天津师范大学'],['山东大学',["新东方", "蓝翔"],'中国海洋大学']]name = schoolNames[1][1]
print(name)

元组
列表是可变的，元组是不可变的

定义
my_tuple = (元素1，元素2，…)
注意
如果元组只有一个元素，不为元组类型；可以加个逗号
(1)–> int；(1,)–>tuple
常见操作
访问元组
通过下标索引
查找元素
index
count
字典
键值对{key:value,…}；字典是无序的，可变的

定义
my_dict = {key1:value1,key2:value2,…}
key值类型必须是不可变的（如列表、字典等都不可），且不能重复（才能完成1对1），一般都使用字符串

常见操作

修改元素/添加元素
格式：字典名[key] = value
如果key不存在，则添加一组键值对；如果key存在，则会覆盖此key原来的值

删除元素

del
删除指定元素，也可以删除整个字典
clear
清空整个字典

>>> info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}>>> del info['name']>>> print('删除后,%s' % info['name'])
Traceback (most recent call last):File "<stdin>", line 1, in <module>
KeyError: 'name'

del info #删除整个字典
info.clear() #清空整个字典 结果为{}
len() 返回键值对的个数

keys 返回一个包含字典所有key的列表

values 返回一个包含字典所有value的列表

items 返回一个包含所有（键，值）元祖的列表

遍历

my_dict = {“name”: “小红”, “age”: 22, “no”: “009”}

遍历-key

for key in my_dict.keys():
print(key)

遍历value

for value in my_dict.values():
print(value)

遍历items

for item in my_dict.items():
print(item[0])

通过设置两个临时变量

for key, value in my_dict.items():
print(“key:”, key)
print(“value:”, value)

enumerate(列表名) 函数

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标

my_list = list("abcd")

不仅要获取列表中的元素 而且需要知道这个元素下标索引

for i, value in enumerate(my_list):print(i,value)

拆包
变量名和值一一对应
可以把函数返回值直接拆包

name,age,no,address = ("zhangsan",20,1,"didian")name,age,no,address = ["zhangsan",20,1,"didian"]name,age,no,address = {"name":"zhangsan","age":20,"no":1,"address":"didian"} #取到的是key值

#批量定义变量
num1, num2, num3, num4 = 10, 20, 30, 40

函数
定义
def 函数名(形参1，形参2，…)：
函数体

pass占位，防止错误

调用
函数名(实参1，实参2，…)
1
缺省参数
给形参设置一个默认值；调用函数时，可根据实际需要决定是否传递参数必须先定义后调用，有先后顺序
注意：在定义函数时若某个形参使用了缺省参数，那么其后面的形参都需要用缺省参数
四种函数类型
无参数、无返回值
无参数、有返回值
有参数、无返回值
有参数、有返回值
函数可嵌套调用
调用函数方式
位置参数
使用位置参数调用函数，需要注意实参的位置–>实参的位置需要和形参的位置一一对应
关键字参数
调用函数的时候使用的是函数的形参名，位置不需要完全对应
函数返回值return
只要函数中执行了return，提前结束函数的执行，且其后的代码将不再执行；可以通过return使执行的函数提前结束以优化性能
可以直接返回不同类型的数据；如return a,b --> tuple return […] --> list ; return{ “key”:value,“key2”:value,…} --> dict ;
函数的文档说明
如果一个自定义函数没有文档说明 ，默认用help会打印函数上面的注释
可以在def下方用""" “”"自动生成文档说明
变量
局部变量
定义在函数内部，作用域仅在函数内部
全局变量
定义在函数外部，作用域为整个模块；
标识全局变量 --> global 变量名
优先级
局部变量>全局变量；python会现在函数内部找变量，若无，再在外部找
匿名函数lambda

对函数的简写

f = lambda a, b : a + b
print(f(10, 20))

等价于

def add2num(a, b):

return a + b

函数作为参数传递

f = lambda x,y:x+y

def fun(a, b, opt):result = opt(a, b)print("result = %d" % result)fun(1, 2, lambda x,y:x+y)

自定义排序(最外层肯定是列表)

格式: 列表名.sort(key=lambda 列表的元素(临时变量): 临时变量[key])

stus = [{"name": "zhangsan", "age": 18}, {"name": "lisi", "age": 19}, {"name": "wangwu", "age": 17}]

按照年龄排序

stus.sort(key=lambda my_dict:my_dict["age"])

按照名字排序

stus.sort(key=lambda my_dict:my_dict["name"])

列表中的列表嵌套

my_list = [[10, 8, 9], [7, 10, 19], [9, 10, 29]]

按照列表元素(小列表)最后一个元素排序

my_list.sort(key=lambda new_list:new_list[2], reverse=True)

列表推导式
快速创建有规律的列表

使用列表推导式 快速创建一个列表

my_list = [ i for i in range(1, 31)]

等价于 # my_list = [] # for i in range(1, 101): # my_list.append(i)

得到一个有30个哈哈的列表

my_list = [“哈哈” for i in range(30)]

定义一个列表 保存数据[1, 50]之间的偶数

列表推导式

my_list = [ i for i in range(1, 51) if i % 2 == 0]

等价于

my_list = []

for i in range(1, 51):

# 判断是否是偶数

if i % 2 == 0:

my_list.append(i)

print(my_list)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
文件操作
文件打开与关闭

打开一个文件 以只读方式 返回一个文件对象

如果使用r模式打开文件，如果文件存在，直接打开；如果文件不存在 会报错

f = open(“hm.txt”, “r”)

关闭文件(打开一个文件就需要消耗内存)

f.close()

打开一个文件 以只写方式 返回一个文件对象；如果以w方式打开文件 会把原来文件的数据清空 然后在写入

如果使用w模式打开文件 如果文件存在 直接打开；如果文件不存在 会创建一个文件 然后打开

open(“hm.txt”, “w”)
f.close()

a 追加数据

f = open(file_name, “a”)

f.write(“nihao”)

f.close()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
文件读写
file_name = “hm.txt”

<1>写数据(write)

f = open(file_name, “w”)

f.write(“hello world”)

f.close()

<2>读数据(read) 如果使用字符串方便

f = open(file_name, “r”)

ret = f.read()

print(ret)

f.close

<3>读数据（readlines） 如果使用列表方便

f = open(file_name, “r”)

把每行的数据保存到列表中

ret = f.readlines()

print(ret)

f.close()

中文读写

f = open(“hmhm.txt”, “w”, encoding=“utf-8”)

# 写入数据

# 默认情况下如果在windows电脑中(中国) 保存中文编码格式为gbk (mac电脑或者是linux 没有问题)

# 如果其他字符 例如abcd 编码格式为utf-8

f.write(“你好世界”)

# 关闭文件

f.close()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
其他操作
导入os模块
import os

文件/文件夹重命名

os.rename(old_fileName,new_fileName)

删除文件

os.remove(fileName)

创建文件夹

os.mkdir(dirName)

获取当前目录（绝对路径）

result = os.getwd()

改变默认目录

os.chdir("…/")

获取目录列表

my_list = os.listdir()

删除文件夹

os.rmdir(dirName)

其他类型文件操作
txt文件

读取

通过此方式打开文件 不需要关闭

as 是给文件起了名字

with open(“hm.txt”, “r”, encoding=“utf-8”) as f:
result = f.read()

写入

f = open(“hm.txt”, “w”, encoding=“utf-8”)
f.write(“hello python!!!”)
f.close()

excel文件

读取

import xlrd
data = xlrd.open_workbook(“student.xlsx”)

获取列表

table = data.sheet_by_index(0)

获取所有的行数

nrows = table.nrows

获取所有的列数

ncols = table.ncols

获取第一行的数据

first_row_name_list = table.row_values(0)
print(first_row_name_list)

定义一个列表保存所有行的数据

info_list = []

遍历所有行

for rownum in range(1, nrows):
row = table.row_values(rownum)
if row:
info_list.append(row)

print(info_list)

写入

import xlsxwriter

打开student.xlsx文件

workbook = xlsxwriter.Workbook(“student.xlsx”)

创建一张工作表

worksheet = workbook.add_worksheet()

设置第一行信息

worksheet.write(0, 0, “学号”)
worksheet.write(0, 1, “姓名”)
worksheet.write(0, 2, “年龄”)

学生信息列表

student_list = [{“name”: “小明”, “age”: 20, “no”: “20170901001”},
{“name”: “小红”, “age”: 21, “no”: “20170901002”},
{“name”: “小刚”, “age”: 20, “no”: “20170901003”},
{“name”: “小海”, “age”: 23, “no”: “20170901004”},
{“name”: “小阳”, “age”: 25, “no”: “20170901005”}]

遍历列表

for i, info in enumerate(student_list):
# 写入数据
# write(第x行, 第x列, 写入的数据)
worksheet.write(i + 1, 0, info[“no”])
worksheet.write(i + 1, 1, info[“name”])
worksheet.write(i + 1, 2, info[“age”])

关闭文件

workbook.close()

json文件

读取

import json

将json对象转成字典 -> 进行解码

with open(“hm.json”, “r”, encoding=“utf-8”) as f:
# 获取文件中数据 -> 字典
new_dict = json.load(f)

# 查看类型
print(type(new_dict))
# 获取名字
print(new_dict["name"])
# 获取年龄
print(new_dict["age"])
# 获取学号
print(new_dict["no"])

写入

import json

定义一个字典

my_dict = {“name”: “老王”, “age”: 30, “no”: “007”}

将字典转成json -> 进行编码

json_str = json.dumps(my_dict)

打印json字符串

print(type(json_str))

把json数据写入到文件中

with open(“hm.json”, “w”, encoding=“utf-8”) as f:
f.write(json_str)

xml文件
// xml示例文件

盒带
1986
3
10
Beyond出品
盒带
1987
1
9
Beyond出品

盒带
1992
8
10
Beyond出品
盒带
1993
6
10
Beyond出品

读取

import xml.dom.minidom

定义一个变量保存文件名

file_name = “xml.xml”

#打开xml文档
domTree = xml.dom.minidom.parse(file_name)

返回文档的根节点

root = domTree.documentElement

返回带有指定标签名的对象的集合(在集合中获取所有电影)

musics = root.getElementsByTagName(“music”)

打印每部电影的详细信息

for music in musics:

print("------音乐------")

如果元素的属性为title

if music.hasAttribute(“title”):
print(“歌名: %s” % music.getAttribute(“title”))

# 格式

type = music.getElementsByTagName(“format”)[0]
print("-格式: %s" % type.childNodes[0].data)
year = music.getElementsByTagName(“year”)[0]
print("-年份: %s" % year.childNodes[0].data)
month = music.getElementsByTagName(“month”)[0]
print("-月份: %s" % month.childNodes[0].data)
start = music.getElementsByTagName(“stars”)[0]
print("-星数: %s" % start.childNodes[0].data)
desc = music.getElementsByTagName(“description”)[0]
print("-描述:%s" % desc.childNodes[0].data)

面向对象基础
区分

面向过程
根据业务逻辑从上到下写代码
面向对象（封装成类，可复用）
将数据与函数绑定到一起，进行封装，这样能够更快速的开发程序，减少了重复代码的重写过程
面向对象三大特性：封装、继承、多态
类和对象

定义
类（抽象）
类名、属性、方法
实例对象
自定义类
class 类名:
方法列表

class Hero: # 经典类（旧式类）

class Hero():

class Hero(object): # 新式类
def info(self):
print(“英雄各有见，何必问出处。”)

object 是Python 里所有类的最顶级父类；

类名 的命名规则按照"大驼峰命名法"；

info 是一个实例方法，第一个参数一般是self，表示实例对象本身，当然了可以将self换为其它的名字，其作用是一个变量 这个变量指向了实例对象

创建对象
对象名1 = 类名()
对象名2 = 类名()
对象名3 = 类名()
class Hero(object): # 新式类
# 1、定义实例方法
def info(self):
“”“当对象调用实例方法时，Python会自动将对象本身的引用做为参数，
传递到实例方法的第一个参数self里”""
print(self)
print(“self各不同，对象是出处。”)

Hero这个类 2、实例化了一个对象 taidamier(泰达米尔)

taidamier = Hero()

3、对象调用实例方法info()，执行info()里的代码

. 表示选择属性或者方法

taidamier.info()

添加和获取对象的属性
class Hero(object):
def move(self):
“”“实例方法”""
print(“正在前往事发地点…”)
def attack(self):
print(“发出了一招强力的普通攻击…”)

实例化了一个英雄对象 泰达米尔

taidamier = Hero()

给对象添加属性，以及对应的属性值

taidamier.name = “泰达米尔” # 姓名
taidamier.hp = 2600 # 生命值
taidamier.atk = 450 # 攻击力
taidamier.armor = 200 # 护甲值

通对.成员选择运算符，获取对象的属性值

print(“英雄 %s 的生命值 :%d” % (taidamier.name, taidamier.hp))
print(“英雄 %s 的攻击力 :%d” % (taidamier.name, taidamier.atk))
print(“英雄 %s 的护甲值 :%d” % (taidamier.name, taidamier.armor))

通过.成员选择运算符，获取对象的实例方法

taidamier.move()
taidamier.attack()

在方法内通过self获取对象属性
class Hero(object):
def move(self):
print(“正在前往事发地点…”)
def attack(self):
print(“发出了一招强力的普通攻击…”)

def info(self):"""在类的实例方法中，通过self获取该对象的属性"""print("英雄 %s 的生命值 :%d" % (self.name, self.hp))print("英雄 %s 的攻击力 :%d" % (self.name, self.atk))print("英雄 %s 的护甲值 :%d" % (self.name, self.armor))

实例化了一个英雄对象 泰达米尔

taidamier = Hero()

给对象添加属性，以及对应的属性值

taidamier.name = “泰达米尔” # 姓名
taidamier.hp = 2600 # 生命值
taidamier.atk = 450 # 攻击力
taidamier.armor = 200 # 护甲值

通过.成员选择运算符，获取对象的实例方法

taidamier.info() # 只需要调用实例方法info()，即可获取英雄的属性
taidamier.move()
taidamier.attack()

魔法方法
__开头，__结尾的方法，是python内置的方法，在特殊情况下被python执行（python可以监听到你使用自定义类创建一个对象）
在自定义类中重写魔法方法

init()方法
监听python使用其类创建对象完成，给这个对象设置属性
在创建一个对象时默认被调用，不需要手动调用
class Hero(object):
“”“定义了一个英雄类”""

def __init__(self, name, skill, hp, atk, armor):""" __init__() 方法，用来做变量初始化 或 赋值 操作"""self.name = nameself.skill = skillself.hp = hpself.atk = atkself.armor = armordef move(self):"""实例方法"""print("%s 正在前往事发地点..." % self.name)
def attack(self):print("发出了一招强力的%s..." % self.skill)
def info(self):print("英雄 %s 的生命值 :%d" % (self.name, self.hp))print("英雄 %s 的攻击力 :%d" % (self.name, self.atk))print("英雄 %s 的护甲值 :%d" % (self.name, self.armor))

实例化英雄对象时，参数会传递到对象的__init__()方法里

taidamier = Hero(“泰达米尔”, “旋风斩”, 2600, 450, 200)
gailun = Hero(“盖伦”, “大宝剑”, 4200, 260, 400)

不同对象的属性值单独保存

print(id(taidamier.name))
print(id(gailun.name))

同一个类的不同对象，实例方法共享

print(id(taidamier.move()))
print(id(gailun.move()))

new()方法
监听python使用其类创建对象，并返回对象 --> init
class A(object):
def init(self):
print(“这是 init 方法”)

def __new__(cls):print("这是 new 方法")return object.__new__(cls)

A()

__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供

__new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例

__init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值

我们可以将类比作制造商，__new__方法就是前期的原材料购买环节，__init__方法就是在有原材料的基础上，加工，初始化商品环节

str()方法
监听对象属性信息的变化，会返回一个字符串，不能添加参数，一般用于调试代码
如果类中实现了__str__()方法，打印对象名，会输出__str__()方法的返回值
class Hero(object):
def init(self, name, skill, hp, atk, armor):
self.name = name
self.skill = skill
self.hp = hp
self.atk = atk
self.armor = armor

def move(self):print("%s 正在前往事发地点..." % self.name)
def attack(self):"""实例方法"""print("发出了一招强力的%s..." % self.skill)def __str__(self):return "英雄 <%s> 数据： 生命值 %d, 攻击力 %d, 护甲值 %d" % (self.name, self.hp, self.atk, self.armor)

taidamier = Hero(“泰达米尔”, “旋风斩”, 2600, 450, 200)
gailun = Hero(“盖伦”, “大宝剑”, 4200, 260, 400)

如果没有__str__ 则默认打印对象在内存的地址。

当类的实例化对象 拥有 str 方法后，那么打印对象则打印 str 的返回值。

print(taidamier)
print(gailun)

del()方法
监听对象销毁后调用的方法
class Hero(object):

# 初始化方法，创建完对象后会自动被调用
def __init__(self, name):print('__init__方法被调用')self.name = name# 当对象被删除时，会自动被调用
def __del__(self):print("__del__方法被调用")print("%s 被 GM 干掉了..." % self.name)

创建对象

taidamier = Hero(“泰达米尔”)

删除对象

print("%d 被删除1次" % id(taidamier))
del(taidamier)

gailun = Hero(“盖伦”)
gailun1 = gailun
gailun2 = gailun

print("%d 被删除1次" % id(gailun))
del(gailun)

print("%d 被删除1次" % id(gailun1))
del(gailun1)

print("%d 被删除1次" % id(gailun2))
del(gailun2)

内存回收机制（粗略）
当使用del() 删除变量指向的对象时，则会减少对象的引用计数。如果对象的引用计数不为1，那么会让这个对象的引用计数减1，当对象的引用计数为0的时候，则对象才会被真正删除（内存被回收）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3ZR9vzfA-1612875771802)(en-resource://database/1124:1)] @w=300h=400
注意
在类内部获取 属性 和 实例方法，通过self获取；
在类外部获取 属性 和 实例方法，通过对象名获取。
继承

单继承
只继承一个父类

定义一个Master类

class Master(object):
def init(self):
# 属性
self.kongfu = “古法煎饼果子配方”

# 实例方法
def make_cake(self):print("按照 <%s> 制作了一份煎饼果子..." % self.kongfu)

定义Prentice类，继承Master

class Prentice(Master):
# 子类可以继承父类所有的属性和方法
pass

laoli = Master()

print(laoli.kongfu)

laoli.make_cake()

damao = Prentice() # 创建子类实例对象
print(damao.kongfu) # 子类对象可以直接使用父类的属性
damao.make_cake() # 子类对象可以直接使用父类的方法

多继承
如果多个父类中有同名的 属性和方法，则默认使用第一个父类的属性和方法（根据类的魔法属性mro的顺序来查找）
class Master(object):
def init(self):
self.kongfu = “古法煎饼果子配方”
def make_cake(self):
print("[古法] 按照 <%s> 制作了一份煎饼果子…" % self.kongfu)
def dayandai(self):
print(“师傅的大烟袋…”)

class School(object):
def init(self):
self.kongfu = “现代煎饼果子配方”
def make_cake(self):
print("[现代] 按照 <%s> 制作了一份煎饼果子…" % self.kongfu)
def xiaoyandai(self):
print(“学校的小烟袋…”)

class Prentice(Master, School): # 多继承（Master在前）
pass

damao = Prentice()
print(damao.kongfu) # 执行Master的属性
damao.make_cake() # 执行Master的实例方法

子类的魔法属性__mro__决定了属性和方法的查找顺序

print(Prentice.mro)

damao.dayandai() # 不重名不受影响
damao.xiaoyandai()

重写
子类继承父类，做自己特有的事情
子类和父类的方法名和属性名相同，则默认使用子类的
子类调用父类同名属性和方法（已重写）
父类类名.父类方法(self) --> self指定调用的对象
class Master(object):
def make_cake(self):
print(“按照 [古法] 制作了一份煎饼果子…”)

class School(object):
def make_cake(self):
print(" 按照 [现代] 制作了一份煎饼果子…")

多继承，继承了多个父类

class Prentice(School, Master):
# 实例方法
def make_cake(self):
print(“按照 [猫氏] 制作了一份煎饼果子…”)

# 调用父类方法格式：父类类名.父类方法(self)
def make_old_cake(self):# 调用父类Master的实例方法Master.make_cake(self)def make_new_cake(self):# 调用父类School的实例方法School.make_cake(self)

实例化对象，自动执行子类的__init__方法

damao = Prentice()

damao.make_cake() # 调用子类的方法（默认重写了父类的同名方法）

damao.make_old_cake() # 进入实例方法去调用父类Master的方法

damao.make_new_cake() # 进入实例方法去调用父类School的方法

damao.make_cake() # 调用本类的实例方法

super()方法
super()默认会调用第一个父类的方法（适用于单继承或者只想使用第一个父类方法的多继承）

class Master(object):
def make_cake(self):
print(“按照 [古法] 制作了一份煎饼果子…”)
class School(Master):
def make_cake(self):
print(“按照 [现代] 制作了一份煎饼果子…”)
# 执行父类的实例方法 -->可以直接在子类一个方法里面调用父类
super().make_cake()

class Prentice(School, Master):
def make_cake(self):
print(“按照 [猫氏] 制作了一份煎饼果子…”)

def make_all_cake(self):# 方式1. 指定执行父类的方法（代码臃肿）# School.make_cake(self)# Master.make_cake(self)# 方法2. super() 带参数版本，只支持新式类# super(Prentice, self).make_cake()# self.make_cake()# 方法3. super()的简化版，只支持新式类# 执行父类的 实例方法super().make_cake()

damao = Prentice()
damao.make_cake()
damao.make_all_cake()

私有属性和私有方法
在属性和方法名前面加了2个下划线’__’，则表明该属性和方法是私有权限，否则为公有权限 -->类似java里的public&private

1. 类的私有属性 和 私有方法，都不能通过对象直接访问，但是可以在本类内部访问；
2. 类的私有属性 和 私有方法，都不会被子类继承，子类也无法访问；
3. 私有属性 和 私有方法 往往用来处理类的内部事情，不通过对象处理，起到安全作用。

class Master(object):
def init(self):
self.kongfu = “古法煎饼果子配方”
def make_cake(self):
print("[古法] 按照 <%s> 制作了一份煎饼果子…" % self.kongfu)

class School(object):
def init(self):
self.kongfu = “现代煎饼果子配方”
def make_cake(self):
print("[现代] 按照 <%s> 制作了一份煎饼果子…" % self.kongfu)

class Prentice(School, Master):
def init(self):
self.kongfu = “猫氏煎饼果子配方”
# 私有属性，可以在类内部通过self调用，但不能通过对象访问
self.__money = 10000

# 私有方法，可以在类内部通过self调用，但不能通过对象访问
def __print_info(self):print(self.kongfu)print(self.__money)def make_cake(self):self.__init__()print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)def make_old_cake(self):Master.__init__(self)Master.make_cake(self)def make_new_cake(self):School.__init__(self)School.make_cake(self)

class PrenticePrentice(Prentice):
pass

damao = Prentice()

对象不能访问私有权限的属性和方法# print(damao.__money)

damao.__print_info()

pp = PrenticePrentice()

子类不能继承父类私有权限的属性和方法

print(pp.__money)
pp.__print_info()

修改私有属性的值
间接通过公有方法
class Master(object):
def init(self):
self.kongfu = “古法煎饼果子配方”
def make_cake(self):
print("[古法] 按照 <%s> 制作了一份煎饼果子…" % self.kongfu)

class School(object):
def init(self):
self.kongfu = “现代煎饼果子配方”
def make_cake(self):
print("[现代] 按照 <%s> 制作了一份煎饼果子…" % self.kongfu)

class Prentice(School, Master):
def init(self):
self.kongfu = “猫氏煎饼果子配方”
# 私有属性，可以在类内部通过self调用，但不能通过对象访问
self.__money = 10000

# 现代软件开发中，通常会定义get_xxx()方法和set_xxx()方法来获取和修改私有属性值。# 返回私有属性的值
def get_money(self):return self.__money# 接收参数，修改私有属性的值
def set_money(self, num):self.__money = numdef make_cake(self):self.__init__()print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)def make_old_cake(self):Master.__init__(self)Master.make_cake(self)def make_new_cake(self):School.__init__(self)School.make_cake(self)

class PrenticePrentice(Prentice):
pass

damao = Prentice()

对象不能访问私有权限的属性和方法

print(damao.__money)

damao.__print_info()

可以通过访问公有方法set_money()来修改私有属性的值

damao.set_money(100)

可以通过访问公有方法get_money()来获取私有属性的值

print(damao.get_money())

多态
定义时的类型和运行时的类型不一样；python中弱化类型（重点在于对象参数是否有指定的属性和方法，如果有就认定合适，而不关心对象的类型是否正确 --> “鸭子类型”）

class F1(object):
def show(self):
print(‘F1.show’)

class S1(F1):
def show(self):
print(‘S1.show’)

class S2(F1):
def show(self):
print(‘S2.show’)

def Func(obj):
# python是弱类型，即无论传递过来的是什么，obj变量都能够指向它，这也就没有所谓的多态了（弱化了这个概念）
print(obj.show())

s1_obj = S1()
Func(s1_obj)

s2_obj = S2()
Func(s2_obj)

内存问题
对象需要占用内存，且和对象属性地址不同
对象的属性也要占用内存，且和对象的地址不同
不同的对象，调用对象方法的地址相同（因为方法中有形参self，可以区分是哪个对象调用的）
python的小整数缓存池（-5~256之间） id相同
字符串 元组 字典 列表 也有缓存池（小于2kb）
类属性和实例属性

类属性就是类对象所拥有的属性

class People(object):
name = ‘Tom’ # 公有的类属性
__age = 12 # 私有的类属性

p = People()

实例属性就是对象属性

class People(object):
address = ‘山东’ # 类属性
def init(self):
self.name = ‘xiaowang’ # 实例属性
self.age = 20 # 实例属性

p = People()

若需要在类外修改类属性，必须通过类对象（Peole.name = ‘xx’）去引用然后进行修改。

如果通过实例对象去引用，会产生一个同名的实例属性，这种方式修改的是实例属性，不会影响到类属性，并且之后如果通过实例对象去引用该名称的属性，实例属性会强制屏蔽掉类属性，即引用的是实例属性，除非删除了该实例属性

类中的方法
实例方法
类方法
class People(object):
country = ‘china’

#类方法，用classmethod来进行修饰
@classmethod
def get_country(cls):return cls.country@classmethod
def set_country(cls,country):cls.country = country

p = People()
print(p.get_country()) #可以用过实例对象引用
print(People.get_country()) #可以通过类对象引用

对类属性进行修改

p.set_country(‘japan’)

print(p.get_country())
print(People.get_country())

静态方法
class People(object):
country = ‘china’

#静态方法
@staticmethod
def get_country(): #没有默认形参return People.country

p = People()

通过对象访问静态方法

p.get_contry()

通过类访问静态方法

print(People.get_country())

总结

• 实例方法(对象方法) -> 场景很多

  • 定义格式: def 实例方法名(self):
  • 调用格式: 对象名.实例方法名()
  • 使用场景: 在方法中需要self

• 类方法-> 对私有类属性取值或者赋值

  • 定义格式: @classmethod
    def 类方法名(cls):
  • 调用格式: 类名.类方法名() 或者 对象名.类方法名()
  • 使用场景: 在方法中需要cls(类名)

• 静态方法 -> 一般不用

  • 定义格式: @staticmethod
    def 静态方法名():
  • 调用格式: 类名.类方法名() 或者 对象名.类方法名()
  • 使用场景: 在方法中不需要self 也不需要cls

单例模式（设计模式）–> 节约内存
定义
确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，单例模式是一种对象创建型模式
单例模式：在程序中这个类创建出来的对象只有一个，也就是只占用一份内存；也**只会运行一次__init __()方法 **–>保证对象地址唯一，保证其对象的属性只会被赋值一次

实例化一个单例

class Singleton(object):
__instance = None
__is_first = True

def __new__(cls, age, name):if not cls.__instance:cls.__instance = object.__new__(cls)return cls.__instancedef __init__(self, age, name):if self. __is_first:self.age = ageself.name = nameSingleton. __is_first = False

a = Singleton(18, “小明”)
b = Singleton(28, “小明”)

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

print(a.age)
print(b.age)

a.age = 19
print(b.age)

异常
捕获异常
try…except
try:
执行可能发生异常的代码
except （异常类型1,异常类型2,…）: #单个异常，多个异常，所有异常（except Exception：…）
如果发生异常执行的代码
1
2
3
4
获取异常信息描述
try:
执行可能发生异常的代码
except （异常类型1,异常类型2,…）as 临时变量：
可以获得临时变量 #print(“exceptions”,e)

try…exceprt…else
else后跟未发生异常的代码
try…except…finally
finally后跟必须要执行的代码
异常的传递
try嵌套中
try嵌套，那么如果里面的try没有捕获到这个异常，那么外面的try会接收到这个异常，然后进行处理，如果外边的try依然没有捕获到，那么再进行传递
import time
try:
f = open(‘test.txt’)
try:
while True:
content = f.readline()
if len(content) == 0:
break
time.sleep(2)
print(content)
finally:
f.close()
print(‘关闭文件’)
except:
print(“没有这个文件”)

函数嵌套中
def my_func1():
try:
print(num)
except:
print(“异常”)

def my_func2():
my_func1()

def my_func3():
my_func2()

my_func3()

模块
模块介绍
变量（全局变量 局部变量 实例属性 类属性）–> 方法（实例方法 类方法 静态方法）–>模块–> 包–>工程（项目）
import
引入格式：import 模块名
使用格式：模块名.全局变量名；模块名.函数名；模块名.类名
from…import
格式：from 模块名 import 全局变量 函数 类
注意：和本模块名字冲突
from 模块名 *：全部导入，使用时不需要写模块名
关键词as–>别名
关键词__all__
如果一个模块中使用了__all__，列表中的字符串才可以在其他模块中使用；但其他模块必须是通过from…import * 方式导入的模块
包
导入格式：包名.模块名 as 别名
————————————————
版权声明：本文为CSDN博主「写Bug的徐同学」的原创文章
原文链接：https://blog.csdn.net/weixin_45890734/article/details/113775662

Python知识点大全--如何学好Python相关推荐

1. Python 知识点大全，建议收藏留用！

   俗话说:技多不压身!自然技术多多更不压身,还会抬身价! 毫无疑问, Python 是当下最火的编程语言之一,学习 Python 的人也越来越多了.学好 Python ,可以进阶至「资深」 Python ...

2. python 数据分析学什么-学好python和数据分析有什么关系？

   原标题:学好python和数据分析有什么关系? 没有一毛钱关系,可能存在一分钱的关系 先从2则高级数据分析师的招聘看起: 第一个: 任职要求: 1.统计学,数学,计算机等专业本科及以上学历,3~8年或 ...

3. python代码大全表解释-python中的字典用法大全的代码

   如下代码是关于python中的字典用法大全的代码. #!/usr/bin/env python # # [SNIPPET_NAME: Dictionaries 101] # [SNIPPET_CATE ...

4. Python库大全涵盖了Python应用的方方面面建议收藏留用!

   学Python,想必大家都是从爬虫开始的吧.毕竟网上类似的资源很丰富,开源项目也非常多. Python学习网络爬虫主要分3个大的版块:抓取,分析,存储 当我们在浏览器中输入一个url后回车,后台会发生 ...

5. 百度Python工程师告诉你学好Python一定要养成的那些

   Python是一种非常简单易学的编程语言,Python可参与web开发.爬虫开发.人工智能开发,都是当下非常火热的岗位.因此学好Python对于就业是十分容易的.虽然Python简单易学,但是如果养成 ...

6. python语法大全-总结了Python中的22个基本语法

   01 Python的优点 Python是一种类似人类讲话的语言 极其简单易学的语言 也是开源的语言之一 可移植性良好,在各大平台都可以运行,比如Windows.Mac.Linux上都可运行 丰富的第三 ...

7. Python资源大全 屌炸Python库

   交互式解析器 交互式 Python 解析器. IPython – 功能丰富的工具,非常有效的使用交互式 Python. bpython– 界面丰富的 Python 解析器. ptpython – 高级 ...

8. 【Python知识点梳理】10.Python的垃圾回收机制、代码规范及命令行参数

   Python的垃圾回收机制.代码规范及命令行参数 文章目录 1.Python的垃圾回收机制 2.Python的引用计数机制 3.Python中的循环数据结构及引用计数 4.Python中的GC模块 5 ...

9. python代码大全表解释-Python中顺序表的实现简单代码分享

   顺序表python版的实现(部分功能未实现) 结果展示: 代码示例: #!/usr/bin/env python # -*- coding:utf-8 -*- class SeqList(object ...

最新文章

1. 学习软件测试需要掌握哪些内容？这篇文章告诉你
2. 【数据竞赛】五大100%奏效的特征筛选策略
3. Java基础-String和StringBuilder类型(11)
4. div不能控制tr和td的隐藏
5. 巨量引擎短视频广告价值白皮书
6. SVN:retrieval of mergeinfo unsupported by
7. 来点硬件知识吧，今天求职吃亏了！
8. 解决centos6.5不能识别NTFS格式的移动硬盘或U盘问题
9. python数字排序_python按照列表元素中的数字大小排序
10. PhysioToolkit 软件目录
11. live2d_基于Qt的Live2D示例（几乎都是官方给的代码就是啦！）
12. js实现简易五子棋游戏
13. mysql安装+navicat激活
14. 世界地图中国地图高清版
15. 10万套PPT模板素材，SmileTemplates全球最大PPT资源下载网站
16. js第六、七天 Array、string
17. iWatermark Pro for Mac(水印制作软件)
18. 拆解PowerApps - 请假申请 - 4
19. TCSVT2021：一种结合全局和局部细粒度特征的行人再识别方法
20. 奥鹏20春季1903C语言,奥鹏20春学期《并行程序设计》在线作业

热门文章

1. opengl处理图片翻转
2. VMware9虚拟机和Fedora12安装-实现Windows和Linux文件共享
3. burpsuite代理监听
4. 外星人计算机组装配置方案,最好的电脑配置_2020年最强最牛的笔记本配置与组装电脑方案...
5. eap wifi 证书_WIFI用户EAP-TLS认证.pdf
6. python画小猪佩奇、星星
7. 【RocketMQ】玩转各种类型的消息
8. ADC中PPM rms dBFS
9. 雷达威力计算 matlab,威力雷达指标
10. 响应式移动端框架_简单，响应式，移动优先导航