系列文章目录
提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加
TODO:写完再整理
前言
认知有限，望大家多多包涵，有什么问题也希望能够与大家多交流，共同成长！本文先对python的模块结构做个简单的介绍，具体内容后续再更，其他模块可以参考去我其他文章
提示：以下是本篇文章正文内容
1.函数def
函数一般的处理过程：输入参数->处理算法->输出结果
在 python 函数定义时有五个要点，分别是 def、函数名、函数体、参数、返回值、以及两个英文版符号：小括号（括号内为参数）和冒号
def： 函数关键字。必须要有，系统看到它，就知道下面是个函数了
函数名：函数的名称。就是给函数起了个名字，当你调用函数时，用函数名就可以直接调用了
函数体：函数中进行的具体操作。就是你这个函数想要实现的功能
参数：提供给函数体。
返回值：当函数执行完毕后，可以给调用者返回想要的数据。
【防盗标记--盒子君hzj】
函数参数
（1）位置参数
def sum(x):
z = x+x
return z
>>sum(10)
20
（2）默认参数
def sum(x,y=12):
z = x+y
return z
>>>sum(10)
22
（3）可变参数
def sum(*numbers):
sum = 0
for n in numbers:
sum =sum +n*n
return sum
>>>sum(10,2,12,3,4)
【防盗标记--盒子君hzj】
（4）关键字参数
def penson(name,age,**kw):
print('name:',name,'age:',age,'other:',kw)
>>>person('zhang san',24,city='changchun')
name:zhang san age:24 other:{'city':'changchun'}
.
.
普通函数
功能：函数的作用可以把功能类似的程序代码段打包，同一管理和调用，其中重载、形参
（默认值参数、关键字参数，收集参数）、返回值等大大增加了函数的灵活性，python的函数灵活度非常高
（1）定义一个函数举例
（1）【无参数，无返回值函数】
def myfirstfunction()：
print("hahah")
print("hahahahaha")
（2）【有参数，有返回值函数】
def mysecfunction(num1,num2)：
print(num1+num2)
return (num1+num2)
【防盗标记--盒子君hzj】
（3）【有默认参数，有返回值函数】
def mysecfunction(num1=1,num2=2)：
print(num1+num2)
return (num1+num2)
（4）【有收集参数】
def mysecfunction(*num)：
print(num[0])
print(num[1])
print(num[2])
print(num[3])
......
注意：
（1）定义一个函数在python中要用关键字def,加上（），再加上冒号：
（2）注意函数内容要缩进，没有C语言中的分号；
（3）python中的输入形参可以不标明数据类型，注意分清形参和实参
【防盗标记--盒子君hzj】
（4）python中的返回值也是用关键字return ,且可以返回任何值，当函数内部没有return，函数默认返回一个none的对象，所以可以锁，python的函数都是有返回值的，想要返回多个数据，在python中可以使用列表元祖，在C语言中可以使用数组，由于列表的功能比数组强大，所以，返回的数据更灵活
（5）当输出参数有默认值得时候，若调用的时候没有给参数就按着默认值参数来，有给参数就按着输入的参数来，这样可以避免调用的时候出现错误
（6）当输入的参数数目不确定的时候，可以使用收集参数，然后用下标的方式在函数里面调用，收集参数的数据 类型不限，如果函数里面既有收集参数也有其他参数，为了避免混乱，在定义的时候加上默认值参数，在调用的时候加上关键字参数
（7）收集参数、关键字参数、默认参数、普通参数可以组合使用
（8）python函数定义的时候不需要指定数据类型，在C语言中函数返回值的数据类型决定了该函数的数据类型，但是python返回值的数据类型会根据返回值动态分配数据类型，所以函数直接用def就行了，不需要声明数据类型
（2）调用一个函数举例
（1）【无参数，无返回值函数】
myfirstfunction()
（2）【有参数，有返回值函数】
mysecfunction(1,2)
（3）【有关键字参数，有返回值函数】
mysecfunction(num1=1,nu2m=2)
注意：
（1）直接输入这个函数名即可
【防盗标记--盒子君hzj】
（2）调用使用关键字参数输入的时候可以不按照参数输入的顺序随意位置给参数
内嵌函数
功能
与C语言不同，C语言定义函数都要单独定义，但是允许在一个函数里调用另外一个函数。python允许在一个函数里面定义并调用另外一个函数
举例：
def fun1():
print("fun1 doing now")
def fun2(): 【在fun1中定义fun2】
print("fun2 doing now")
fun2() 【在fun1中调用fun2】
fun1() 【在全局下调用fun1】
【输出fun1 doing now、fun2 doing now】
注意：
（1）python中函数的内嵌函数fun2()只能在被嵌函数fun1()内进行调用，fun2()不能再全局下进行调用 ,否则会报错
闭包close
定义
python在一个函数fun1()里面定义并调用另外一个函数fun2()，而被调函数fun2()使用了函数fun（）的参数，这是允许的，因为都在同一个作用域中。其中x是fun2()的外部变量
举例
def fun1(x):
def fun2(y):
return x*y
ruturn fun2
fun1(1) 【这样调用会范湖fun1的对象】
fun1(1)(2) 【这样是正确的调用方式，返回2】
lambda语句
功能：
这是精简版本的函数表达式，在冒号之前是函数的输入参数，在冒号之后是函数返回的值
举例
【普通的函数定义】
（1）单输入参数
def fun(x)
return 2*x+1
（2）多输入参数
def add(x,y):
return x+y
【lambda语句定义】
（1）单输入参数
lambda x:2*x+1 【返回的是function的对象】
a=lambda x:2*x+1 【返回的是2*x+1的值】
（2）多输入参数
g=lambda x,y:x+y
【lambda语句调用】
（1）单输入参数
a(5) 【返回的是11】
（2）多输入参数
g(2,3) 【返回的是5】
注意
（1）lambda语句返回的是一个function的对象，我们仅仅需要对齐进行赋值就可以知道返回值得结果
（2）使用lambda语句可以省下定义函数的过程，是代码更精简
（3）lambda语句适用于功能简单的输入输出运算函数，还省下了定义函数的过程
【防盗标记--盒子君hzj】
python自带的过滤器filter
功能
根据自己对数据的过滤要求编写一个function函数，使用该函数进行数据过滤
举例
（1）【使用None】
list(filted(None,[1,0,False,True])) 【返回的是1，True，功能是筛选非0数据】
（2）【使用function】
def odd(x): 【用于分辨奇偶数】
return x%2
temp=range(10)
show=filter(odd,temp)
list(show) 【输出的是2，4，6，8，10】
（3）【使用function+lambda语句】
list(filter(lambda x:x%2,range(10))) 【输出的是2，4，6，8，10】
注意
（1）在filter（）的第一输入中若输入None则无过滤函数，若输入fun()则根据fun()进行数据过滤
（2）在filter（）的第二输入是输入要筛选的数据
（3）返回的是一个对象，要用list进行提取并赋值
（4）若筛选的对象元素为True则通过筛选输出出来
【防盗标记--盒子君hzj】
python自带的过滤器map
功能
映射功能，将迭代的序列进运算，将输入序列中的每个变量作为函数的输入，进行运 算，将运算得到的结果组成一个序列进行输出
举例
list(map(lambda x:x*2,range(5))) 【输出的是2，4，6，8，10】
递归
功能：函数调用自身函数，从而实现功能，注意有一个确定的停止条件
举例：
【递归去阶乘】
def fun(n):
if n==1:
return 1
else:
return n*fun(n-1)
fun(5) 【返回的是120,5的阶乘】
注意：
（1）python规定递归的深度默认不能超过100层，但是可以设置递归的深度
【通过import sys 】
【sys.setrecursionlimit(1000)】【设置了递归深度为1000】
（2）使用递归的方法要注意，不然很容易进入死循环，不断调用自己，消耗内存
（3） 使用递归的方法要设置递归停止的条件，不然就会不断循环
（4）递归比较耗硬件，但是比较容易读懂
【防盗标记--盒子君hzj】
python常用的内置函数
（1）max()
功能;
选出列表和元祖中值最大的元素
举例：
num=(1,2,3,4,5,6)
max(num) 【返回的是6】
max(1,2,3,4,5,6) 【返回的是6】
注意：
（1）用于比较的元素数据类型要一致
（2）min()
功能;
选出列表和元祖中值最大的元素
举例：
num=(1,2,3,4,5,6)
min(num) 【返回的是1】
min(1,2,3,4,5,6) 【返回的是1】
注意：
（1）用于比较的元素数据类型要一致
（3）sum()
功能;
把列表和元祖中的元素相加
举例：
num=(1,2,3,4,5,6)
sum(num) 【返回的是21】
sum(1,2,3,4,5,6) 【返回的是21】
sum(num,8) 【返回的是29】
注意：
（1）用于相加的元素数据类型要一致，且一定是数值的数据类型
（2）允许外加参数进行相加
【防盗标记--盒子君hzj】
（4）sorted()
功能;
把列表和元祖中的元素按一定顺序排序
举例：
num=(1,3，5，7，9，2，4，6，8)
sorted(num) 【返回的是1,2,3,4,5,6,7,8,9】
注意：
（1）用于排序的元素数据类型要一致，且一定是数值的数据类型
（5）reversed()
功能;
把列表和元祖中的元素翻转排序
举例：
num=(1,2,3,4,5,6,7,8,9)
list[reversed(num)] 【返回的是9,8,7,6,5,4,3,2,1】
注意：
（1）返回的是一个迭代器对象，要用list转换成一个列表
（6）enumerate()
功能;
把列表和元祖中的元素加上一个枚举序号打印出来
举例：
num=(1,2,3,4,5,6,7,8,9)
enumerate(num) 【返回的是[(0,1),(1,2),(2,3),(3,4),(4,5),(5,6),(6,7),(7,8),(8,9)]】
注意：
（1）返回的是一个元素类型为元祖的列表
（7）zip()
功能：
把对应的参数成对打包一起
【防盗标记--盒子君hzj】
举例：
num1=(1,2,3,4）
num2=(5,6,7）
zip(num1,num2) 【输出的是[(1,5),(2,6),(3,7)]】
注意：
(1)输出的是一个列表，把对应的元素放在同一个元祖里面，不成对的元素舍去
python的内置函数【数据结构的底层函数】
功能：
python提供常用的函数，而且内置在了数据类型上
举例：
【改写整型的加法内置函数，改成减法】
class New_int(int): 【New_int是继承int的】
def __add__(self,other):
return int.__sub__(self,other)
def __add__(self,other):
return int.__add__(self,other)
a=New_int(3)
b=New_int(5)
c=a+b
c 【输出是-2.因为改了整型数据类型的数据结构】
注意：
（1）如整型的数据类型内置了加减乘除的函数，既可以使用重载运算符进行运算，也可以使用内置函数进行运算
（2）尽量使用python内置函数就好了，不要轻易改变这些内置函数，因为它们是程序的底层，上层的重载运算符“+-*/”实质上都是调用这些内置函数
常用的python内置函数
【1】 __add__(self,other) ->"+"
【2】 __sub__(self,other) ->"-"
【3】 __mul__(self,other) ->"*"
【4】 __truediv__(self,other) ->"/"
【5】 __floordiv__(self,other) ->"//"
【6】 __mod__(self,other) ->"%"
【7】 __divmod__(self,other) ->"divmod()"
【8】 __pow__(self,other) ->"**"
【9】 __lshift__(self,other) ->"<<"
【10】__rshift__(self,other) ->">>"
【11】__and__(self,other) ->"&"
【12】__xor__(self,other) ->"^"
【13】__or__(self,other) ->"|"
python底层（内置函数，魔法方法）
.
.
2.类与对象
面向对象（Object Oriented）特征
（1）封装
功能：把相同的实现过程打包起来，同一管理和调用，封装起来后，不用知道其功能的内部实现，仅仅知道该功能怎么调用就行了
【防盗标记--盒子君hzj】
举例：
（1）列表、元祖、字典、字符串等的内置函数其实都是封装的例子，我们只管调用就行
（2）继承
功能：继承是子类自动共享父类的属性和方法的机制，这样可以避免相同的属性和方法重复定义，造成代码段冗余的缺点，站在巨人的肩膀上
举例;
【1、创建一个继承类】
class Myclass(list): 【Myclass这个子类继承了list这个父类】
pass
【2、创建一个子类的对象】
list2=Myclass(list)
【3、子类对象的调用】
list2.append(1) 【子类对象list2继承了父类对象list的append()方法】
list2.append(2)
list2.append(3)
list2 【输出的是[1,2,3]】
（3）多态
功能：
不同对象对同一方法响应不同的行动，就是程序能根据不同对象输出不同的结果
【防盗标记--盒子君hzj】
举例：
（1）对于跑这个功能函数，不同对象如猪，狗，羊等，跑的姿态和速度是不一样的
（2）
【定义两个类，都拥有fun这个方法】
class A:
def fun(self):
print("我是 A")
class B:
def fun(self):
print("我是 B")
【创建一个两个类的对象】
a=A()
b=B()
【子类对象的调用】
a.fun() 【输出的是“我是A”】
b.fun() 【输出的是“我是B”】
注意:
（1）多态要区别于重载函数
注意：
（1）python是一个纯粹的面向对象范式
类与对象
一般方法：
（1）创建一个类
（2）创建对象,类的实例化
（3）对象的访问及使用使用
【防盗标记--盒子君hzj】
（1）创建一个类
class Turtle: 【创建一个类，一般是以大写字母开头】
#属性（变量）
color='green'
legs=4
weitht=10
#方法（函数）
def climb（self）:
print("我正在爬")
def run(self)
print("我在跑步")
（2）创建对象,类的实例化
animal=Turtle() 【用Turtle这个类创建一个对象】
（3）对象的访问及使用使用
animal.climb() 【调用这个对象的方法】
注意：
（1）对象、属性和方法的关系：对象=属性（变量）+方法（函数）
（2）类和对象的关系：我们需要用类创造一个对象，类其实是一个模板，通过类可以很轻松的定义一批对象，这就是类的优点
（3）python中的类一般以大写字母开头的
【防盗标记--盒子君hzj】
（4）用类生成对象的过程称为类的实例化
（5）注意区分类、类对象、和类的实例化的概念，彼此是相对独立的
（6）如果属性和方法的名字相同，属性会把方法覆盖掉，在设计程序的时候不要把属性和方法定义成同样的名称
（7）定义类要小巧，不要一个类包含太多东西，这样会导致类的通用性不高，要学会使用继承，组合，多态的方法对类进行充分利用
关键字self
功能：self相当于C++中的this指针
举例：
【定义一个类，用self可以说明用这个类生成的每个对象都有自己的独立性】
class Ball:
def setname(set.name):
self.name=name
def kick(self):
print("我是%s",self.name)
【用类生成对象】
a=Ball()
b=Ball()
【对象的操作】
a.setname('A')
b.setname('B')
a.kick() 【输出的是A】
b.kick() 【输出的是B】
【防盗标记--盒子君hzj】
注意：
（1）由一个类能生成多个对象，这多个对象都有相似的方法和属性，对象调用的时候难以区分，所以要有一个self,定义的时候专门指向每个对象，对号入座
（2）用self可以说明用这个类生成的每个对象都有自己的独立性
（3）self这个参数在对象调用的时候不用理会（给参数）
公有和私有
功能：和C++语言一样，给对象的方法和属性设置权限，进行保护
举例：
class Person:
__name='HZJ' 【定义name是私有成员】
def getName(self):
return self.__name
p=Person() 【创建一个对象】
p.name 【报错,无法在外部调用私有变量】
p.__name 【报错，无法在外部调用私有变量】
p.getName() 【返回的是HZJ ，可以通过对象的方法调用私有变量】
p._Person__name 【返回的是HZJ ，为私有机制的体现，可以通过【对象名+类名+私有变量名（函数名）】调用私有变量】
注意：
（1）python中没有像C++语言一样有public\private\protect的关键字
（2）python中定义私有变量只需要在变量名或者函数名前面加上“__”两个下划线，那么这个函数或变量就会变成私有变量了
（3）python的私有机制是伪私有机制，python的类是没有权限控制的，仅仅改了对所谓的私有成员改了一个名字而已，本质上可以直接调用私有成员，但是编程上不建议这么做
【防盗标记--盒子君hzj】
继承
功能：继承是子类自动共享父类的属性和方法的机制，这样可以避免相同的属性和方法重复 定义，造成代码段冗余的缺点，站在巨人的肩膀上
语法：
在创建子类的时候添加基类的名字
class DerivedClassName(BaseClassName):
......
举例：
【创建基类】
class Parent:
def hello(self):
print("正在调用父类")
def haha(self):
print("haha")
【创建子类】
class Child(Parent):
def haha(self):
print("enen")
【创建对象（类的实例化）】
p=Parent()
c=Child
【对象的操作】
p.hello() 【返回“正在调用父类”】
c.hello() 【返回“正在调用父类”】
p.haha() 【返回的是haha】
c.haha() 【返回的是enen】
注意：
（1）说明子类已经继承了父类的所有属性和方法
（2）如果子类中定义与父类同名的方法或者属性，则子类的方法和属性会自动覆盖父类对应的方法或者属性
（3）注意使用同一个类生成的多个对象彼此独立，不能相互干扰，继承机制是针对类的，不是针对对象的，类（模板）有继承机制，对象没有继承机制，但是有丰富的类（模板），就可以生成丰富的对象，继承机制对对象的影响是间接的
【防盗标记--盒子君hzj】
多继承
格式：
class BaseClassName_1:
......
class BaseClassName_2:
......
class BaseClassName_3:
......
class DerivedClassName(BaseClassName_1,BaseClassName_2,BaseClassName_3):
......
注意 ：
（1）多继承能够快速的搭建起一个对象，但是也容易导致代码混乱
类的绑定
定义：
（1）在python中要求方法有实例才能被调用，这种限制就是python的绑定机制,简单来说就是类一定要实例化才能调用里面的属性和方法，其他都是不合法的
类的内置函数
（1）issubclass(class,classinfo)
功能：
判断两个类是不是子类和基类的关系，如果是则返回True,反之返回False
【防盗标记--盒子君hzj】
举例：
class A：
pass
class B(A)：
pass
class C：
pass
issubclass(A,B) 【返回的是True】
issubclass(A,A) 【返回的是True】
issubclass(A,C) 【返回的是False】
注意：
（1）一个类会认为自己是自己的子类，就是认为自己及时爸爸又是儿子
（2）classinfo可以是类的对象组成的元祖，只要class与其中任何一个候选类的子类，则返回True
（3）Obiect默认是所有类的基类
（2）isinstance(Object,classinfo)
【防盗标记–盒子君hzj】
功能：
判断一个对象是不是由改类（模板）生成的
举例：
class A：
pass
class B(A)：
pass
a=A()
isinstance(a,A) 【返回的是True，因为a是A的实例化对象】
isinstance(a,B) 【返回的是True，因为a是A的实例化对象，而A是继承于B的】
注意：
（1）如果第一个参数不是传入一个对象Object，则永远返回的是False
（2）如果第二个参数不是传入一个类或者有类对象组成的元祖，则会抛出一个类型错误的异常
（3）如果要判断的类是子类，那么该子类的基类也认为是该对象的生成的，血缘一脉相承的
（3）hasattr(Object,name)
功能：判断一个对象是否存在指定的属性（变量）
【防盗标记--盒子君hzj】
举例：
class A：
def __init__(self,x=0): 【带默认参数】
self.x=x
a=A() 【创建一个对象】
hasattr(a,'x') 【返回Ture，判断x这个属性属不属于对象a】
注意：
（1）attr=attribute是属性的意思
（2）Object是要判断的对象，name是要判断的属性名（变量），但是属性要用字符串的方法括起来'name'不然识别不了
（4）getattr(object,name[,default])
功能：判断一个对象是否存在指定的属性（变量）
举例：
class A：
def __init__(self,x=0): 【带默认参数】
self.x=x
a=A() 【创建一个对象】
getattr(a,'x'，“若不存在返回的提示语句”) 【 返回Ture，判断x这个属性属不属于对象a】
getattr(a,'h'，“若不存在返回的提示语句”) 【 返回若不存在返回的提示语句】
注意：
（1）用法和hasattr一致，Object是要判断的对象，name是要判断的属性名（变量），但是属性要用字符串 的方法括起来'name'不然识别不了
（2）多出来[,default]是可选的，若不设置功能和hasattr一致，设置为如果返回False，打印自己设置的提示 内容
（3）优点是用户体验更好
【防盗标记--盒子君hzj】
（5）setattr(object,name,value)
功能：判断一个对象是否存在指定的属性（变量），若存在返回True，若不存在则新建这个属性
举例：
class A：
def __init__(self,x=0): 【带默认参数】
self.x=x
a=A() 【创建一个对象】
setattr(a,'x'，“haha”) 【 返回Ture，判断x这个属性属不属于对象a】
setattr(a,'h'，“haha”) 【新建h=haha这个属性军区这个类】
（6）delattr(object,name)
功能：删除对象中指定的属性，若属性存在于对象中，则直接删除，若属不性存在于对象中，则返回异常
举例：
class A：
def __init__(self,x=0): 【带默认参数】
self.x=x
a=A() 【创建一个对象】
setattr(a,'h') 【报错，抛出异常】
setattr(a,'x') 【直接删除属性x】
（7）property(fget=None,fset=None,fdel=None,doc=None)
功能：通过属性来操作属性，可以快速的访问属性、设置属性、和删除属性
举例：
class C:
def __init__(self,size=10):
self.size=size
def getsize(self):
return self.size
def setsize(self,value):
self.size=value
def delsize(self)
del self.size
property(getsize,setsize,delsize)
【防盗标记--盒子君hzj】
c=C()
c.x 【返回10，通过属性x来访问属性】
c.x=18 【返回的是18，通过属性x来设置属性】
del c.x 【删除属性x】
注意：
（1）当程序进行大概的时候，给用户的接口名称可以不用改变，仅仅需要改变类内的接口部分名称
python的魔法方法【一般应双下划綫表示】
（1）init(self)【构造方法】
功能：构造方法，相当于C++中的构造函数，用于初始化属性（变量）的值,初始化属性（变量）一般表示为self.XXX
举例：
class Ball:
def __init__(self,name=HZJ): 【这里的name使用了默认参数，默认参数可以在函数里面进行修改】
name=name
def kick(self):
print("我是%s",self.name)
class sBall(Ball):
def __init__(self,name1):
Ball.__init__(self,name=HZJ) 【方法一：name继承基类，name1是子类新添加的属性】
super().__init__(self,name=HZJ)【方法二：使用super()函数可以自动索引继承的基类的方法和属性，两种方 法本质是一致的】
name1=name1
def kick(self):
print("我是%s",self.name)
print("我是%s",self.name)
【防盗标记--盒子君hzj】
a=Ball()
a.kick() 【输出的是HZJ,具有默认参数】
b=Ball('A') 【创建对象的时候同时给属性赋值】
b.kick() 【输出的是A】
c=sBall(name1=haha)
c.kick() 【返回的是HZJ，haha】
注意：
（1）__init__(self)中的self是this的作用，但是后面可以有其他属性，而且这些属性还能有默认参数
（2）如果子类有自己的__init__(self)，则表明有自己的构造函数，相当于重写覆盖了父类的方法和属性，特别注意不要出错，想要既继承基类的__init__(self)，又添加自己的__init__(self)，则在子类的__init__(self)中在次声明基类的__init__(self)即可。
（3）继承基类使用super()函数不用给定基类的名字，会自动索引，这在多继承机制上省了非常多代码，在多继承机制上更有优势，本质上基类的索引在class后面的基类就有体现
（4）构造函数__init__(self)不能返回东西，不然会报错
（5）__init__(self)方法在创建一个类的时候就会被自动调用
（2）del(self)【析构方法】
功能：当类的对象被完全删除的时候，python会启动垃圾回收机制，调用__del__(self)，解 除对内存的占用
举例：
class C:
def__init__(self):
print("我是init函数，正在调用")
def__del__(self):
print("我是init函数，正在调用")
c=C() 【这时候会自动调用init函数，输出"我是init函数，正在调用"】
del c 【删除c这个对象，会自动调用del函数，输出"我是del函数，正在调用"】
注意：
（1）魔法函数都是系统会自动调用的
【防盗标记--盒子君hzj】
.
.
3.类的组合
功能：
类里面嵌套类，称为类的组合，把不同功能的类组合在一起完成一个任务，
这是一种强组合的方法（在创建组合类的时候就进行组合），
其实也可以用松组合的方法（要用的时候在进行组合使用）,组合方法本质其实是类里面嵌套调用类
举例：
【统计水池里面有多少条鱼和多少只乌龟】
class Turtle
def __init__(self,x);
self.num=x
class Fish
def __init__(self,x);
self.num=x
class Pool
def __init__(self,x,y);
self.turtle=Turtle(x)
self.fish=Fish(y)
def output(self)
print(”水池里面有%d调鱼，有%d只乌龟“%（self.turtle.num,self.fish.num）)
【防盗标记--盒子君hzj】
注意：
（1）组合可以理解成为横向的继承，继承可以理解为纵向的继承
.
.
.
4.局部变量和全局变量
举例：
count=10 【定义全局变量count为10】
def myfun();
//global count 【如果使用了global关键字就可以访问修改全局变量】
count=5 【定义局部变量为5】
print(count)
def myfun() 【输出的是10】
print(count) 【输出的是5，说明全局变量并没有被改变】
注意：
（1）注意全局变量和局部变量的的作用域,还要注意的是全局变量尽量不要去修改它，仅仅访问他就好了
（2）由于python没有变量的定义，所以没办法从定义中区分局部变量和全局变量，在函数里面是自动屏蔽掉全局变 量的想要在函数里访问和修改全局变量要加上关键字global
.
.
5.标准库及random模块、range模块
random模块
1、功能：生成一个随机数，用于测试程序带有不确定性的情况，或者程序初始化需要覆盖原有信息的情况
2、注意：
（1）random是一个模块，类似于一个功能包，里面有很多可以调用的函数
（2）使用这个模块的时候要在最前面导入，类似添加一个功能包一样【import random 】
3、调用例子
（1）a=random.randint(1,10)【随机生成一个整型的数据,范围在1到10之间】
【防盗标记--盒子君hzj】
range模块
1、功能：生成一个从start的参数值到stop参数值得（平均）数字序列
2、语法：range([start,] stop [,step=1])
-- 有三个参数，中括号里面的是可选参数,即起始值和步长是可选的
-- step的默认值是1
3、例子
（1）range(5) 【输出0，1，2，3，4】
（2）range(2，9) 【输出2，3，4，5，6，7，8 是不包括9的】
（3）range(2，9，2) 【输出2，4，6，8】
4、注意
（1）经常和for循环一起配合使用
（2）常常用来生成一个列表，如
list(range(5)) 【生成0，1，2，3，4】
【防盗标记--盒子君hzj】
.
.
6.导入外部模块
导入模块的简单调用方法
（1）功能：可以减少调用模块的时候，复杂的模块名称的编写（弄个别名）
（2）格式：
import 模块名称 as模块别名
（3）举例：
import numpy as py
模块（理解成子文件）
功能：模块包含所有定义的函数和文件，后缀名是py，模块就是可用代码包的打包，需要导 入（import）进来，导入进来后便可以在自己的文件程序中调用模块的函数等功能
（1） OS模块（operation systen操作系统）
【防盗标记--盒子君hzj】
功能：
不同操作系统的驱动底层是不一样的，需要OS模块进行兼容，所以ypthon能兼容不同平台和语言的原因就在这里，我们并不需要知道操作系统具体使用什么模块，OS模块会根据我们的需求自动选择和调用不同操作系统的底层模块
注意：
（1）os模块关于文件/目录有很多常用的函数，自行百度使用方法
（2）要使用模块的内容，就要导入改模块 import os
（3）和linux的操作指令类似功能和用法
（2）pickle模块
功能：把小程序段或者共享数据和调试数据永久存放一个文件里面（硬盘里—） ，这些小程序段往往是数据而不是算法，这是针对保存代码调试的数据用的 ，用于检查和共享，把数据单独存放起来，代码更整洁
注意：
（1）pickle模块是以二进制的方法进行存储的
.
.
7.python工具及库
（1）矩阵库——NumPy
支持高维数组与矩阵运算，提供了大量的数学函数库
1 ndarray 对象
2 创建数组
（1）创建单维数组
采用列表方式 a0 = np.array([1,2,3,4])
采用元组方式 a1 = np.array((1,2,3,4))
（2）创建多维数组
a = np.array([[1,2,3],[2,3,4],[4,5,6]])
【防盗标记--盒子君hzj】
（3）自动生成数组
linspace()方法 a = np.linspace(0,10,10)
对于 linspace()，它的前两个值和 arange()一样，代表开始值和终值，但有个区别是 linspace()默认包括终值，如果你不想包括终值，加上 endpoint = False 即可，对于第三个值它是指元素的个数，这个和 arange 不一样，一定不要混淆
arange()方法 a = np.arange(0,1,0.1)
arange()的第一个值代表开始值，第二个值代表终值（不包括
这个值），最后一个值代表步长（间隔）
（4）创建随机数组
numpy.random 模块
a = np.random.rand(2,2)
b = np.random.randn(2,2)
c = np.random.randint(0,9,(2,2))
其他方法
np.zeros() :生成元素全是 0 的数组
np.zeros_like(a):生成形状和 a 一样且元素全是 0 的数组
np.ones()：生成元素全是 1 的数组
np.ones_like(a):生成形状和 a 一样且元素全是 1 的数组
3 存取数组–下标和切片的方法
a = np.array([4,2,3,5,9,0,,6,8,7])
print(a[3]) 表示获取第四个位置的元素
print(a[3:5]) 表示获取第四个位置和第五个位置的元素
print(a[::-1]） 表示从最后一个元素到第一个元素，该方法省略了开始下标和结束下 标，这时候开始下标就是对应第一个元素，结束下标就对应着最后一个数，-1 表示步长为 1，负号从后往前数
【防盗标记–盒子君hzj】
4 NumPy 常见函数使用
1 数组维度变换
（1）reshape():（）里面的参数就是你想要转换成的数组的形状
a = np.arange(0,10,1)
b = a.reshape(2,5) #reshape()函数把一个 1 维数组，变成了一个 2 行 5 列的一个数组
c = a.reshape(2,-1) #-1 代表自动生成的意思,已经指定了数组的行是 2 行，那么系
统就会自动生成一个 5 列
d = a.reshape(-1,5)
（2）swapaxes()：将一个数组的第 0 轴和第 1 轴进行了交换
a = np.arange(10).reshape(2,5)
b = a.swapaxes(0,1)
（3）reshape(-1)、flatten()和 ravel()：将多维很容易就变成了1 维数组
a = np.arange(10).reshape(2,5)
b =np.flatten()
c = a.reshape(-1)
d = a.ravel()
2 堆叠数组
hstack()
vstack()
a = np.array([1,2,3,4])
b = np.array([5,6,7,8])
c = np.hstack((a,b)) #行堆叠
d = np.vstack((a,b)) #列堆叠
【防盗标记--盒子君hzj】
.
.
.
（2）数据可视化——matplotlib
1pyplot 模块绘图
import matplotlib.pyplot as plt
import numpy as np
x= np.linspace(0,10,100)
y=np.sin(x)
plt.figure(figsize=(8,4))
plt.plot(x,y)
plt.show()
xlabel,ylabel：分别设置 X，Y 轴的标题文字
title：设置标题
xlim,ylim：分别设置 X,Y 轴的显示范围
legend:显示图例
2 matlibplot 读取图像
import matplotlib.pyplot as plt
img = plt.imread("02.jpg")
plt.imshow(img)
plt.show()
imread：图像的读取
imshow()：图像的显示
3 matplotlib 工具栏
【防盗标记–盒子君hzj】
（3）科学计算与数据处理库SciPy 和 Pandas
待补充~
.
.
.
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
