我们在前面的学习中学会了一个叫type（）的函数，用它来判断变量的类型，变量和它当下存储的数据绑定在一起。例如
a = [4,5,6,7]
print(type(a)）
输出
a = range（10，20，2）
print（type（a））
输出
a = True
print（type（a））
输出
a = {‘a54’：56}
print（type（a））
输出
a = {‘a54’，56}
print（type（a））
输出
a = ‘tyuio’
print（type（a））
输出
a = 2
print（type（a））
输出
我们发现：就连最基本数字、字符都是以class类的形式出现，实际上python 是在类的思想指导下开发的，python不仅用类定义了基本的数据类型，还向用户开放了定义类的权力，让用户根据自己的数据和编程动机定义自己的类。
如何定义类？类又有哪些作用？让我们从一段简单的代码开始逐步了解类：
新建一个clstest.py的文件，编写以下代码
1 class Tieban: #注意类名的首字母需大写
2 def __init__(self,tezheng1,tezheng2):
3 self.tezheng1 = tezheng1 # 第一个属性
4 self.tezheng2 = tezheng2 # 第二个属性
5 def xianshi(self):
6 print(self.tezheng1,self.tezheng2)
7 print('你的材料已准备')
新建一个clsuse.py 的文件，编写以下代码并执行
8 from clstest import Tieban
9 a = input('铁板长：')
10 b = input('铁板宽：')
11 gaizi =Tieban(a,b) # 构建一个对象
12 gaizi.xianshi()
运行clsuse.py文件后输出：
铁板长：33
铁板宽：44
33 44
你的材料已准备
解释上诉代码：第1行，声明一个叫Tieban（铁板）的类
第2，3，4行，是一个构造函数， __init__是构造函数统一的函数名，函数的 参数是self 及其它的参数，上例中给出了tezheng1（特征）和tezheng2两个参数，3、4行在函数体内进一步将实例参数指向构造参数，self.tezheng1表示这个类被使用时的实例参数，它指向,tezheng1这个构造参数。
第5，6，7行定义了一个实例方法，方法名xianshi（显示），6，7行是该实例方法的具体操作：打印两个实例变量，答应一段提示‘你的材料已准备’
以上7行代码完成了类Tieban 的定义，说明了类定义的基本结构：
类声明：
构造函数
方法函数
规范的类的定义是放在一个单独的文件中。
在clsuse.py文件中
第8行 from clstest import Tieban是从clstest文件中导入Tieban 类
第9，10行让用户输入两个数
第11 行用变量gaizi 实例化了类Tieban，并将刚刚录入的a ，b 的值赋值给gaizi 这个类实例
第12行调用了实例gaizi的实例方法gaizi.xianshi.(实例名gaizi替换了定义时的slef）。
关于类的知识点比较多，初学者理解也有一定的难度。上例是一个特别简单例子
为的是让初学者掌握类定义，类实例化的大概语句组织轮廓。
类的基本知识点由以下几部分组成：
1、类的声明。（。）
2，类属性和类变量，
3，构造函数。--init– 是构造函数的专有符号。
4、类方法。
5、 实例方法
6、类的实例化
7、实例中调用方法
有时类名后会用一个括号说明该类的父类，本文仅作入门只用，子类父类以及继承多态的知识请读者在掌握基本的知识之后进阶学习，这方面的资料很多
通过以下学生的例程，理解掌握《类和实例关系对照表》中3对关系
在使用用户类的时候与python 基础类的时候的异同点：python几乎所有的编程要素都是建立在类的基础上的，但面对具体问题时，用户需要自己设计类来优化编程效率并使程序规范更容易阅读，更容易复用。
函数
我们在上面的两个小例子中已经使用了函数的概念，接下来展开介绍函数的基础知识
在面向过程的编程时代，函数是编程的主题。但随着编程思想的发展，类的思想成为主流。但函数作为一种代码封装工具，依然有重要的作用。
函数也是语句的封装，给一堆代码起一个名字，以便于用它来解决许多相似问题。
python 有很多的内置函数：下表是网上搜集的最常用的68个内置函数
abs() dict() help() min() setattr()
all() dir() hex() next() slice()
any() divmod() id() object() sorted()
ascii() enumerate() input() oct() staticmethod()
bin() eval() int() open() str()
bool() exec() isinstance() ord() sum()
bytearray() filter() issubclass() pow() super()
bytes() float() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed() __import__()
complex() hasattr() max() round()
delattr() hash() memoryview() set() reduce()
-----------------------------------
68 个 Python 内置函数详解
https://blog.51cto.com/u_11949039/5060113
内置函数功能学习
这些内置函数可以解决很多遇到的问题，只有当内置函数及其组合方案无法解决是才有必要自己造轮子。当然学习和练习时除外。所以内置函数的学习目标是：了解内置函数，在遇到问题时，知道有相应的函数实现了这个功能，而不必自己编写代码实现就够了。
其实在说到设计函数时，尤其是在复习这部分知识，我希望把自己定位到一位初学者，举一些既简单，又有代表性的而且还有趣的例子，为了节省时间，又增加有趣性，我打算在函数方面借助codex来生成例程，codex 给出的例程要好过我自己设计的，但对函数的要求，以及通过例子要练习和掌握哪些函数方面的知识，则有我来把控。
要求：当给定一个列表，去除其中最大的两个数和最小的两个数
codex：
def remove_ends(lst):
lst.sort()
return lst[2:-2]
a = [1,2,3,4,5,6,7,8,9,]
print(remove_ends(a))
这段代码，巧妙的使用了一次排序和一次切片解决问题
但是你可以在网络上找到很多好的函数的例程。设计类比设计函数要复杂的多，这需要结合实际的计算需求。我希望初学者一开始就把学习的注意力转移到数据类型和创建类方面，好的数据构造，强过处理它的细节，所以关于函数的知识在本文中会尽量基础，尽量简短，尽可能的把精力和篇幅放到类的研究上。
def 是创建函数的标识符，
def 函数名（参数）
语句和操作
return 返回计算结果给调用语句（return 语句可以有不同分支，分情况返回不同的结果
但只要一条return语句被执行，函数就结束
return 可以返回任何变量（包括全局变量和局部变量）任何数据，可以给出参数，也可以没有参数；在不需要返回任何值时也可以直接用return 返回空值（None）从而结束函数执行。有时不需要返回时，return 写不写都可以，没有return的函数也很常见。
def add(a,b):
c = a + b
return c #当调用add函数时，将相加结果c 的值返回
m = add(3,4) #调用add（），3，4传入参数a，b
print(m)
print(add(10,20))
输出：7 ，30
return 语句做什么，全在于你的设计，我们来看一个返回值和函数体毛关系没有的例子
def fuuck(a,b,c):
m = a
a = b
b = c
c = m
return '今天是个好日子，大把的钞票送给你'
print(fuuck(2,4,8))
输出 今天是个好日子，大把的钞票送给你
我们发现，return 和我们的参数，和其他语句做的事情风牛马不相及。我仅仅是恭喜你发财而已。
再来看看return选择输出的例子
def kaoshi():
a = input('你这次考试成绩？：')
a = int(a)
if a<60:
return '你个渣渣'
elif a<=100:
return '还不错'
else:
return '吹牛B'
print(kaoshi())
我们发现在上例中，3个return语句根据你输入的情况选择执行。
没有return 的情况
def ppt(a,b):
print('a的取值是：%s,b的取值是：%s'%(a,b))
c = '差不多'
d = '还可以'
ppt(c,d)
输出：a的取值是：差不多,b的取值是：还可以
了解了函数的输出，我们回过头来学习函数参数的知识：
什么是函数的参数？对于一个求和函数来讲，如上例add（a，b）中的a，b就是add 的参数，要求两个数求和，就必须在调用时给出两个数3，4，而函数在设计时准备用于接受3，4的a，b就叫add（a，b） 的参数，参数一般写在函数名后的括号里。
a，b 也叫形式参数：形参，3，4 也叫实际参数：实参，一般情况要保持个数一致，顺序一致。形参和实参的关系就好比席位和客人的关系，有几位客人，就准备几个席位。
除了形参和实参一一对应的情况，还有许多特殊的情况：
1、默认参数：add2(a=1,b=2,c=3)，在设计函数时给形参一个值，在调用的时候可以由调用语句修改这个参数，也可以不修改，不修改时，函数运行中变量取默认值，range函数就是典型的代表，它的初始值和步长有默认值0和1
.默认参数的例子
def lilu(a,n=1,l=0.04):
shouyi = a*n*l
print('您%s元%s年存款的收益是：%s元'%(a,n,shouyi))
print(lilu(1000)) #这时使年限和利率l保持默认值
print(lilu(1000,3,0.05)) #这时修改为3年，利率调整为0.05
print(lilu(1000))
输出
您1000元1年存款的收益是：40.0元
None
您1000元3年存款的收益是：150.0元
None
您1000元1年存款的收益是：40.0元 默认参数被修改后再次调用时还原成默认值
None
默认参数必须指向不可变对象，结合基础数据类型中的不可变类型知识理解这一规则。
2、可变参数，不定参数
def biancanhansu(a, *bian):
print(a)
print(bian)
biancanhansu(1, 2, 3, 4,8)
输出1
(2, 3, 4, 8)
上例中*bian是一个可变参数，用一个*标识可变参数，意味着我不确定有几个元素，在调用函数时，先给固定参数分配数据，没用完的数据作为一个元组整体传给可变参数bian
3，关键字参数
def a(**guanjian):
print(guanjian)
a(x=1,y=2,z=3)
输出
{'x': 1, 'y': 2, 'z': 3}
关键字参数在定义时用两个星号**标识，在传递实参时是以（key1 = value1，key2 = value2，key3 = value3）的形式成对（等号两边）给出。关键字参数接收值后以字典的形式存储，所以也称作字典参数。
普通参数，可变参数，关键字参数同时出现时，应先定义普通参数（当然包含默认参数），再定义可变参数，最后定义关键字参数。在调用传值时，也应该按这个顺序并且保证书写正确，尤其是关键字参数的‘键=值‘的形式。下例给出一个3种参数混合使用的情景。
def a(b,c=10,*tt,**guanjian):
print(b)
print(c)
print(tt)
print(guanjian)
a(45,11,'ju',54,87,'ji',x=1,y=2,z=3)
输出
45
11
('ju', 54, 87, 'ji')
{'x': 1, 'y': 2, 'z': 3}
注意：在传递可变参数时，字符串要加引号，而在传递关键字参数时，键名不能加引号。键名必须是可hash的，不接受纯数字等不可哈希的键名，要按照字典键名的规则来书写。
类如何传参数？类是通过类变量和构造函数来传递参数的。构造函数既然是函数，函数的传参规则是否适用于构造函数呢？
class Qwqw:
def __init__(self,b,c=10,*tt,**guanjian):
self.b = b
self.c = c
self.tt = tt
self.guanjian = guanjian
print(self.b)
print(self.c)
print(self.tt)
print(self.guanjian)
li1 = Qwqw(45,11,'ju',54,87,'ji',x=1,y=2,z=3)
输出
45
11
('ju', 54, 87, 'ji')
{'x': 1, 'y': 2, 'z': 3}
可见构造函数的参数规则与普通函数一样。
在分配实例变量时不写*星号。
如何把参数传递给类变量？这个很难找到相关资料，或许这种情况很少见。不过类变量是可以随时单独赋值操作的。还有个办法是构造时写一条语句将实例变量或参数传给类变量，，实例化时传参给实例变量就好。
观摩和练习
为了加深对函数知识的掌握，这里设计了一些情景，先自己动手编写函数，然后再对照给出的方案。
1、 str1 = '小燕子，往南飞'
str2 ='白燕子，往北飞'
str3 = '黑燕子坐飞机'
str4 = '红燕子装暖气'
请找出往北飞的燕子
import re
def find_string(str):
pattern = re.compile(r'北')
match = pattern.search(str)
if match:
print(match.group())
return True
else:
print('Not found')
return False
if __name__ == '__main__':
str1 = '小燕子，往南飞'
str2 ='白燕子，往北飞'
str3 = '黑燕子坐飞机'
str4 = '红燕子装暖气'
find_string(str1)
find_string(str2)
find_string(str3)
find_string(str4)
print(find_string(str1))
print(find_string(str2))
以上程序调用了re正则表达式模块，re 模块有十分强大的文本匹配功能，要有所了解。
if __name__ == '__main__':是一条申明语句，意思是当文件被整体执行时，if下面的语句才被执行，当文件作为模块加载而不是整体执行时，if后面的语句就不执行，但文件中的函数是可以被调用的。
还可以用in | not in成员运算符来判断
def find_string(str):
#list = [one for one in str]
if '北' in str:
print(****'有北*****：‘，str）
return True
else:
print(' 不含‘北’字')
return False
str1 = '小燕子，往南飞'
str2 ='白燕子，往北飞'
str3 = '黑燕子坐飞机'
str4 = '红燕子装暖气'
find_string(str1)
find_string(str2)
find_string(str3)
find_string(str4)
print(find_string(str1))
print(find_string(str2))
输出：不含‘北’字
******有北******： '白燕子，往北飞
不含‘北’字
不含‘北’字
不含‘北’字
False
有北
True
2、.定义一个桌子类（Desk），包含长（length）、宽（width）、高（height）属性，包含一个打印桌子信息属性的方法（showInfo）。实例化2个桌子对象，为其赋予不同的属性值，并调用showInfo方法，输出每个桌子的信息
class Desk:
def __init__(self, length, width, height):
self.length = length
self.width = width
self.height = height
def showInfo(self):
print("长：%d，宽：%d，高：%d" % (self.length, self.width, self.height))
desk1 = Desk(1, 2, 3)
desk2 = Desk(4, 5, 6)
desk1.showInfo()
desk2.showInfo()
# 2.定义一个电脑类（Computer），包含CPU（cpu）、内存（memory）、硬盘（hardDisk）属性，包含一个打印电脑信息属性的方法（showInfo）。实例化2个电脑对象，为其赋予不同的属性值，并调用showInfo方法，输出每个电脑的信息
class Computer:
def __init__(self, cpu, memory, hardDisk):
self.cpu = cpu
self.memory = memory
self.hardDisk = hardDisk
def showInfo(self):
print("CPU：%s，内存：%s，硬盘：%s" % (self.cpu, self.memory, self.hardDisk))
computer1 = Computer("i7", "16G", "1T")
computer2 = Computer("i5", "8G", "500G")
computer1.showInfo()
computer2.showInfo()
# 3.定义一个人类（Person），包含姓名（name）、年龄（age）、性别（sex）属性，包含一个打印人信息属性的方法（showInfo）。实例化2个人对象，为其赋予不同的属性值，并调用showInfo方法，输出每个人的信息
class Person:
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
def showInfo(self):
print("姓名：%s，年龄：%d，性别：%s" % (self.name, self.age, self.sex))
person1 = Person("张三", 18, "男")
person2 = Person("李四", 20, "女")
person1.showInfo()
person2.showInfo()
# 4.定义一个学生类（Student），继承自人类，包含学号（id）、班级（class）属性，包含一个打印学生信息属性的方法（showInfo）。实例化2个学生对象，为其赋予不同的属性值，并调用showInfo方法，输出每个学生的信息
class Student(Person):
def __init__(self, name, age, sex, id, className):
super().__init__(name, age, sex)
self.id = id
self.className = className
def showInfo(self):
print("姓名：%s，年龄：%d，性别：%s，学号：%d，班级：%s" % (self.name, self.age, self.sex, self.id, self.className))
student1 = Student("张三", 18, "男", 1, "一班")
student2 =
（以上代码由codex 生成）
5定义一个用户类(User),用户名(username)和密码(password)是这个类的属性。
（1）实例化两个用户,分别有不同的用户名和密码。
class User:
def __init__(self, username, password):
self.username = username
self.password = password
def change_password(self, new_password):
self.password = new_password
def verify_password(self, password):
return self.password == password
def verify_username(self, username):
return self.username == username
def print_user_info(self):
print("username: %s, password: %s" % (self.username, self.password))
if __name__ == "__main__":
user1 = User("user1", "123456")
user2 = User("user2", "123456")
user1.print_user_info()
user2.print_user_info()
user1.change_password("654321")
user1.print_user_info()
print(user1.verify_password("654321"))
print(user1.verify_username("user1"))
5、创建一个列表，其中存储了3个Point对象。每个点（Point)都在与x,y轴夹角为45度的直线上（意思是x和y的值相同）。打印输出这些点的坐标。例如：
>x坐标：1，y坐标：1
>x坐标：2，y坐标：2
>x坐标：3，y坐标：3
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
p1 = Point(1, 1)
p2 = Point(2, 2)
p3 = Point(3, 3)
points = [p1, p2, p3]
for point in points:
print('x坐标：{}, y坐标：{}'.format(point.x, point.y))
Scala面向对象练习题34道
https://cloud.tencent.com/developer/article/1912677?from=article.detail.1775168
模块，库的概念：
拥有函数，变量，类的程序文件都可以被别的程序引用，这个.py文件相对于引用他的文件就叫模块。
很多的模块文件组合到一起，就形成了库的概念，python 拥有琳琅满目的库，包含但不限于，网络开发，科学计算，人工智能，图像，音频，工业控制，数据库等领域近千个库。
在一个.py 文件中用import 引入别的文件和文件夹时，就可以使用被引入的资源了。