python基础4

函数：

“”"

def => define 定义

def function_name(args-参数列表)：

​ statement1

return values => 需要有返回值，要使用return,可以return多个值

“”"

形参：形式参数，定义在函数时的参数叫形参

实参：实际参数，实际传递的时候叫做实参

函数也是一种数据类型，是一种function类型的数据，可以定义

函数的参数：

*args:参数的复数arguments：可以传递多个参数

一个或多个位置参数

规定：关键字参数必须放在参数列表的末尾，从第一个关键字参数开始，后边必须都是关键字参数

没指定关键字，传参的时候根据顺序默认去找

即使你定义的参数不是关键字参数，也可以根据参数名去指定

def function_args(arg1,arg2,*args):

​ print(args)

function_args(1,2,3,4,5,6)

arg1,arg2,会被占位，不显示，也可以单给予变量显示

**kwargs:keyword args

*后边必须是关键字参数

定义个函数，使输入的数字，显示几行九九乘法表

文档字符串：

访问文档字符串：

怎么对函数去注解：

1、参数的注解

2、返回值的注解

sort 排序 ：

lanbda 表达式 ：匿名函数

格式：lambda arguments: expression 有返回值，返回值是冒号后边的

高阶函数：

map , reduce , filter

map :

map 的结果 : 有几个取决于最短最短的列表里有几个元素 ，每个元素里有几个值，取决于返回值

map 对象可通过list列表转换

filter：过滤

reduce：

zip：

输入的是可迭代的ui想，输出：多个元组

结束的条件：其中最短的耗尽了

最后返回：zip object

zipobj有几个：取决于最短的可迭代对象长度

​ 每个元素有几个值，取决于有几个列表元素

访问一个文件夹，列出所有的文件，以树形结构

先在D盘创建文件

书写规范：

什么是类？

类，是对象的模子，具有相同属性和方法的一组对象的集合，类是不存在的，是用来描述对象的信息

什么是对象？

对象是类的具体表达，而类则是对象的抽象表达

类的定义：

class ClassName:

​ 类属性

​ pass

类里边可以有哪些东西：

属性：数据属性，方法属性

数据属性：变量

方法属性：函数

包含在类中的内容也有缩进

在类里边的函数一般称为方法

EG:

实例化一个对象的啥时候：新建对象，初始化操作（一定要新建对象，再初始化）

_ _ new _ _ :Create and return a new object

_ _ init _ _ : Initialize self 初始化自己 （我们可以自定义）

print(type(lisi.__init__))
<class 'method'>

初始化对象的属性：

# def __init__(self,name,age,gender):
	  #对象属性
#     self.name = name
#     self.age = age
#     self.gender = gender

class Person:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
    def __str__(self):
        return self.name + "-"  + self.gender + "-" + str(self.age)
 zhangsan = Person("zhangsan", 18 , "nan")
lisi = Person("lisi", 20 ,"nan")
print(zhangsan)
print(lisi)
print(zhangsan.name)
print(lisi.name)

#执行结果
#zhangsan-nan-18
#lisi-nan-20
#zhangsan
#lisi

重写：方法的原型不变，只是里边的内容做更改

​ 方法的功能不变，只是内容做更改

_ _ getattribute _ _ _ _ setattr _ _

继承：

单继承：class ClassName(Parent1,Parent2,…)

class Animals(object):
    def __init__(self,name):
        self.name = name
        print("Animals")
    def run(self):
        print(f"{self.name} is running")
        print("Animals")
class Lion(Animals):
    def __init__(self,name):
        self.name = name
        print("Lion")
    pass
class Tiger(Animals):
    pass
lion = Lion("狮子")
tiger = Tiger("老虎")
print(lion.name)
print(tiger.name)
lion.run()
tiger.run()

多继承：

class A:
    def print_obj(self):
        print("A")
class B:
    def print_result(self):
        print("B")
class C(A,B):
    pass
c = C()
c.print_obj()
c.print_result()

#执行结果
A
B

class A:
    def print_obj(self):
        print("A")
class B:
    def print_result(self):
        print("ZB")
class C(A,B):
    pass
class D(A,B):
    pass

c = C()
c.print_obj()
c.print_result()
d = D()
d.print_obj()
d.print_result()

#执行结果
A
ZB
A
ZB

定义类，重写方法

class Person:
        def __eq__(self, other):
        return True
    def __lt__(self, other):
        return True
    def __gt__(self, other):
        return True


if zhangsan == lisi :
    print("equal")
if zhangsan < lisi:
    print("zhangsan less than lisi")
if zhangsan > lisi :
    print("zhangsan greater than lisi")
    
 #执行结果   
equal
zhangsan less than lisi
zhangsan greater than lisi

多线继承（三线继承）：

class F():
    def print_obj(self):
        print("F")
class A:
    def print_obj(self):
        print("A")
class B(F):
    def print_result(self):
        print("ZB")
class C(A,B):
    pass
class E(F):
    pass
class G(B,E):
    pass
class K(C,G):
    pass

k = K()
print(K.__mro__) #多重继承查找的顺序

#执行的结果
(<class '__main__.K'>, <class '__main__.C'>, <class '__main__.A'>, <class '__main__.G'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.F'>, <class 'object'>)

polymorphism 多态

用一个类型，接收多个类型的形态

class Animals():
    def __init__(self,name):
        self.name = name
    def run(self):
        print(f"{self.name} is running")
class Lion(Animals):
    pass

class Tiger(Animals):
    pass

class Elephant(Animals):
    pass

def play(animals):
    animals.run()

lion = Lion("Lion")
tiger = Tiger("Tiger")
elephant = Elephant("Elephant")
play(lion)
play(tiger)
play(elephant)


#执行结果
Lion is running
Tiger is running
Elephant is running

重载：定义一个函数test，只需传一个参数，再定义个函数test，也叫同一个名字，但需要传两个参数

根据你又几个参数来判断调用哪一个方法

def test(arg1):
    print("test1")
def test(arg1,arg2):
    print("test2")

test(1,2)
#执行结果
test2

重写：将等于，大于，小于，进行重写，运用

class Person:
#         def __eq__(self, other):
#         return True
#     def __lt__(self, other):
#         return True
#     def __gt__(self, other):
#         return True
#
#
# if zhangsan == lisi :
#     print("equal")
# if zhangsan < lisi:
#     print("zhangsan less than lisi")
# if zhangsan > lisi :
#     print("zhangsan greater than lisi")

“python中单下划线和双下划线的区别是:单下划线用来告诉别的程序这个属性或方法是私有的;双下划线用来定义私有类的实例、类变量、全局变量、实例变量等。”

class Test:
    def __init__(self):
        print("Initialize")
        #防止被覆盖：_ClassName + MethodName
    def __test_double(self):
        print("Double")
    #私有变量的规定或规范，所以一定要遵守
    #from module import * :出来_开始的函数或类
    def _test_single(self):
        print("Single")

test = Test()
print(dir(test))
test._Test__test_double()
test._test_single()

#执行结果
Initialize
['_Test__test_double', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_test_single']
Double
Single


#再定义一个子类
class SubTest(Test):
    pass

sub_test = SubTest()
sub_test._test_single()
sub_test._Test__test_double()

#执行结果
Initialize
Single
Double

Initialize
['_Test__test_double', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_test_single']
Double
Single


#再定义一个子类
class SubTest(Test):
    pass

sub_test = SubTest()
sub_test._test_single()
sub_test._Test__test_double()

#执行结果
Initialize
Single
Double