比较运算是布尔类型的数据（ture，false）

如何定义变量和使用:

a=10 int（整数类型）

a=‘吴老师’str（字符串类型）

a=12.67 float（浮点类型）

a=True bool （布尔值）

b=（）tuple（元组类型）

c=【】list（列表类型）

d={}dict （字典类型）

变量的命名不能以数字来开头

变量区分大小写

关键字不能定义 

如何定义变量和使用:

a=10 int（整数类型）

a=‘吴老师’str（字符串类型）

a=12.67 float（浮点类型）

a=True bool （布尔值）

prog:文件名

usage:用途描述

description：文件描述

epilog

#!usr/bin/env python 
# -*- coding:utf-8 -*- 
""" 
@author: haozhengwei 
@file: 类方法和静态方法.py 
@time: 2022/01/10 
@desc: 
"""
# 类方法：类对象所拥有的方法，需要用装饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数，
# 类方法可以通过类对象、实例对象调用
class People:
    country='China'
    #类方法需要用@classmethod修饰
    @classmethod
    def get_country(cls):
        return cls.country
        pass
    @classmethod
    def change_country(cls, data):
        cls.country=data#在类方法中修改类属性
        pass
    pass
print(People.get_country())#通过类对象去引用
P=People()
print('实例对象访问', P .get_country())
People.change_country('英国')
print(People.get_country())


# 静态方法：类对象所拥有的方法，需要用@staticmethod来表示，静态方法不需要任何参数。
class Person(object):
    country ='China'
    def __init__(self, name):
        self.name = name
    #静态方法用staticmethod装饰
    @staticmethod
    def get_country():
        print(Person.country)

people = Person('xiaoming')
result = Person.get_country()#注意，一般情况下，我们不会通过实例对象去访问静态方法，减少资源开销。
#为什么要使用静态方法呢？
#由于静态方法主要来存放逻辑性的代码，本身和类以及实例对象没有交互，在静态方法中不会涉及到类中方法和属性的操作。
#数据资源能够得到有效利用

#demo 返回当前时间
#返回当前的系统时间
import time
class TimeTest:
    def __init__(self,hour, min, second):
        self.hour = hour
        self.min = min
        self.second = second
    @staticmethod
    def showTime():
        return time.strftime('%H:%M:%s',time.localtime())
        pass
    pass
print(TimeTest.showTime())
t=TimeTest(2, 10, 5)
print(t.showTime())

#类方法、实例方法、静态方法对比
# 1、类方法的第一个参数是类对象cls，通过cls引用的类对象的属性和方法；
# 2、实例方法的第一个参数是实例对象self，通过self引用的可能是类属性、也有可能是实例属性
# 不过，存在相同名称的实例属性和类属性的情况下，实例属性的优先级更高。
# 静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类对象来引用。

调用父类方法

可以显式的用  父类名.__init__(self,param, param)

也可以用：

super.__init__(self, param)(自动找到父类，进而调用方法）

#!usr/bin/env python 
# -*- coding:utf-8 -*- 
""" 
@author: haozhengwei 
@file: jicheng.py 
@time: 2022/01/10 
@desc: 
"""

# 在python中展现面向对象的三大特征，封装、继承、多态
# 封装：指的是把内容存储在某个容器中，便于以后的调用。
# 他需要：
# 把内容封装到某个地方，比如属性、方法的定义就是封装；在另外一个地方调用被封装的内容
# 对于封装来说其实就是使用初始化构造方法将内容封装到对象中，然后通过对象直接得获得被封装的内容，或者通过self简洁的获得被封装的内容
# 继承：子可以继承父的内容【属性和行为】类所有的，类-实例都有；相反，类-实例有的，类不一定有；
# 所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，而不必一一实现每个方法；
# 这样可以提高代码编写效率，精简代码的层级结构；比较清晰便于扩展；
# class 类名（父类名）：
#     '''子类继承父类中公共的属性和方法'''
    # pass

# 多继承
# 比如C可以继承A和B两个父类的属性和方法
# class A(object):
#     print('a')
#     pass
#
# class B(object):
#     print(B)
#     pass
#
# class C(A,B):
#     print('I am son of A and B')
#     pass

class Shenxian:
    def fly(self):
        print('神仙都会飞')
        pass

class Monkey:
    def chitao(self):
        print('猴子喜欢吃桃子')
        pass

class Sunwukong(Shenxian, Monkey):#孙悟空既是神仙也是猴子
    pass

swk = Sunwukong()
swk.fly()
swk.chitao()


# 问题：当多个父类当中存在相同方法的时候，应该去调用哪一个？
# 直系优先，先就近级别搜索；没有则再上一级别；可以用__mro__方法查看，比如swk.__mro__
# 在类的传递过程中，我们把父类称为基类，子类称为派生类，父类的属性和方法可以一级一级的传递到子类；
# 一般情况下在做类的设计的时候，一般不超过3级
# 重写父类中的方法：所谓重写，就是子类中，有一个和父类同名的方法，在子类中的方法会覆盖掉父类中的同名方法

__init__(self)方法：

__init__(self)方法，初始化方法，实例化对象的时候调用，完成一切初始化设置。

#创建一个动物类：

class Animal(object):

实例方法：在类的内部，使用def关键字可以定义一个实例方法，与一般函数定义不同，类方法必须包含参数self，且为第一个参数。

class Animal(object):

#实例方法，试用def关键字定义，第一个形参默认传实例对象本身，一般使用self作为第一个参数

面向过程：根据业务逻辑从上到下写代码；首先思考这件事情怎么按照步骤去实现，然后将问题拆解为若干个步骤，并将这些步骤对应成方法一步一步的最终完成这些功能；
面向过程，关注如何做，不适合做大项目
函数式编程：将某功能代码封装到函数中，日后无序重复编写，仅调用函数即可。
面向对象编程：将数据与函数绑定到一起，进行封装，这样能够更快速的开发程序，减少了重复代码的重写过程。
面向对象：oop [object oriented programming]是一种Python的编程思路；关注的是设计的思维，【找洗车店，给钱洗车】
面向对象适合做更大的项目；不注重细节过程，注重思考谁（对象）来做。

面向对象与面向对象编程：按人们认识客观世界的系统思维方式，采用基于对象（实体）的概念建立模型，模拟客观世界分析、设计、实现软件的办法
面向对象编程（Object Oriented Programming-OOP)是一种解决软件复用的设计和编程方法。这种方法把软件系统中相似、相近的操作逻辑和操作应用、
数据、状态，以类的形式描述出来，以对象、实例的形式在软件系统中复用，以达到提高软件开发效率的作用。

类和对象的概念
类就是模板、模型，模板里可以包含一些函数，函数里实现一些功能。
对象则是根据模板创建的实例，通过实例可以执行类中的函数。
类相当于制造汽车的图纸，对象相当于根据图纸制造出来的汽车。

类的组成部分：
类(Class) 由3各部分组成：
类的名称
类的属性：一组数据
类的方法：类可以操作的方法（行为）

例如：创建一个人类
食物名称（类名）：人
属性：身高、体重、年龄、肤色
方法：吃、跑

类是具有一组相同或相似特征（属性）和行为（方法）的一系列对象的组合

对象：是实实在在的一个东西，是类的具象化、实例化。
类是对象的抽象，对象是类的实例（凝聚态）

具有相同或相似属性和行为的一系列对象的集合都可以抽象出一个类
例如：小明开着他的宝马去逛街
小明--->可以抽象出人类
宝马--->可以抽象出车类

集合：

set()是python中的一种数据类型，是一个无序且不重复的元素集合

不支持索引和切片，是一个无序且不重复的容器

创建集合的方式

1、set1 = {"1", "2"}

2、list1 = ['1', '2', '3', '4']

set2 = set(list1)

集合操作函数

add()

clear()

difference()差集

intersection()交集

union()并集

pop()从集合中删除数据

discard()指定元素移除

update()更新

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

语法：enumerate(sequence, [start=0])

参数：

sequence--一个序列、迭代器或其他支持迭代的对象

start -- 下标起始位置

返回enumerate（枚举）对象

seasons = ['spring', 'summer', 'fall', 'winter']

list(enumerate(seasons))

[(0, 'spring'), (1, 'summer'), (2, 'fall'), (3, 'winter')]

sorted()函数对所有可迭代的对象进行排序操作

sort 与sorted 区别

sort是应用在list上的方法

sorted可以对所有可迭代对象进行排序操作

list的sort方法返回的是对已经存在的列表进行操作

内键函数sorted方法返回的是一个新的list，而不是在原来的基础上进行的操作

语法：sorted(iterable[, key[, reverse]]])

参数：

iterable -- 可迭代对象

cmp -- 比较的函数，这个函数具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1, 等于则返回0

key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序

reverse -- 排序规则， reverse - True降序，reverse - False升序（默认）

返回值：返回重新排序的列表

案例：

sorted([1, 2, 3, 5, 6, 9])

[1, 2, 3, 5, 6, 9]

sorted([1, 2, 3, 5, 6, 9].reverse=False)

[1, 2, 3, 5, 6, 9]

sorted([1, 2, 3, 5, 6, 9], reverse=True)

[9, 6, 5, 3, 2, 1]

sorted(['a', 'b', 'C', 'D', 'd'].key=str.lower)(字符串无关大小写排序）

['a', 'b', 'C', 'D', 'd'] 

元组不能用sort，因为元组一单定义，不能修改。

range()函数可创建一个整数列表，一般用在 for 循环中

语法： range(start, stop[, step])

参数：

start: 计数从start开始，默认是从0开始，例如range(5)，等价于range(0, 5)

stop:计数到stop结束，但不包括stop,例如：range(0, 5)是【0, 1, 2, 3, 4]没有5

step： 步长，默认为1 例如：range(0, 5)等价于range(0, 5, 1)

zip()函数用于将（成对的）可迭代的对象作为参数，将各对象中对应的元素(按照索引位置顺序排列）打包成一个个元组，然后返回有这些元组组成的列表

如果各个迭代器的元素个数不一致，则返回列表的长度与最短的对象相同，利用*号操作符，可以将元组解压为列表

语法zip([iterable,...])

参数：iterable --一个或多个迭代器；

返回值：返回元组列表

zip([1,2,3], ['a', 'b', 'c'])

<zip object at0x......

a=zip([1,2,3], ['a', 'b', 'c'])

list(a)

[1,'a'),(2, 'b'), (3, 'c')]

序列操作函数：

all()用于判断给定的可迭代参数iterable中的所有元素是否都为TRUE，如果是，返回True，否则返回False元素，除了0、空、FALSE外都算TRUE

序列对象：str 元组、list

函数等价于：

def all(iterable):

      for element in iterable:

           if not element:

                return False

       return False

语法：all(iterable)

参数：iterable -- 元组或列表

返回值：如果iterable的所有元素不为0、‘’、False或者iterable为空，all(iterable返回TRUE，否则返回FALSE

注意：空元祖、空列表返回值为True,这里要特别注意

案例：

li = [1, 2, 3]

all(li)

True

li = [1, 2, 3, 0]

all(li)

False

any()

函数用于判断给定的可迭代参数iterable是否全部为FALSE，则返回False, 如果有一个为True, 则返回True

元素除了是0、空、False外都算TRUE

函数等价于：

def any(iterable):

      for element in iterable:

           if element:

                return True

      return False

语法：any(iterable)

参数：iterable -- 元组或列表

返回值：如果都为空、0、False，则返回False, 如果不都为空、0、False, 则返回True

案例：

li = [1, 2, 3, 0]

any(li)

True 

安逸result： bool类似于逻辑运算符or的判断，只要有一个元素为TRUE结果就为True

sorted()

reverse()

zip()

enumrate 

类型转换

int()

hex()将10进制转换成16进制（0x开头）

bin()把10进制转换成二进制

chr()数字转字符

bool()

list():将元组转换为列表

tuple()将序列转换为元组

bytes()转为字节数组

描述：bytes()方法返回一个新字节数组，这个数组里的元素是可变的，并且每个元素的值范围：0<= x < 256

语法：class bytearray(source[, encoding[, errors]]])

参数

source为整数，则返回一个长度为source的初始化数组

source为字符串，则按照指定的encoding将字符串转换为字节序列；

source为可迭代类型，则元素必须为[0,255]中的整数；

source为与buffer接口一致的对象，这次对象也可以被用于初始化bytes

如果没有输入任何参数，默认就是初始化数组为0个元素

返回值：返回新字节数组

什么是内置函数：

所谓内置函数就是python安装后就自带有的函数，如同人一生下来就有手脚，会吃喝一样，具备基本的能力，随着成长和学习，我们学会了说话、学会了工作，学会了技能等，而这些能力就如同我们Python的扩展函数或扩展库。

常用数学运算函数

abs() 求绝对值

round()对浮点数取近似值，保留几位小数点

语法round(x[, n])

参数：

*  x--数值表达式

*  n--数值表达式

返回值：返回浮点数x的近似值

注意：这里不完全是按照传统的四舍五入或者四舍六入五成双来去值得，取值和python的版本有关，还和浮点数精度有关

pow()

divmod()求商和余数

max()求最大值

返回给定参数的最大值，参数可以为序列；

语法max(x, y, z, ……）

参数：

x, y, z: 数值表达式

sum():对系列进行求和计算

语法：sum(iterable[, start])

参数：iterable - 可迭代对象，如：列表、元组、集合。

start -- 指定相加的参数，如果没有设置这个值，默认为0

返回值：返回计算结果

min()

eval()执行字符串表达式

描述：eval()函数用来执行一个字符串表达式，并返回表达式的值

语法：eval(expression[, global[s, locals]])

参数：

expression - 表达式

globals - 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象

locals - 变量作用域，局部命名空间，如果被提供，可以是任何映射对象

返回值： 返回表达式计算结果

任何一门编程语言的核心操作都是操作内存中的数据，但内存中的数据优势通过编程语言的API来实现，所谓API，就是系统提供给我们的函数，有一种函数是系统预先定义的函数，也就是我们安装python就自带的函数，我们把这种函数称为内置函数，也叫内嵌函数。

递归函数的优缺点：

优点：

1、递归使代码看起来更加整洁、优雅

2、可以用递归将复杂任务分解成更简单的子问题

3、试用递归比试用一些嵌套迭代更容易

缺点：

1、递归逻辑很难调试，递归条件处理不好容易造成程序无法结束，直到达到最大递归错误

2、递归占用大量内存，耗费计算机资源

递归函数

递归函数：如果一个函数在内部不调用其他函数，而是调用自己本身的话，这个函数就是递归函数

求阶乘：

5! = 5*4*3*2*1

def factorial(n):

     if n == 1

         return 1

    return n * factorial(n-1)

递归函数的条件：递归函数必须有一个结束条件，否则递归无法结束，会一直递归下去，直到到达最大递归深度报错。

优点：逻辑清晰简单，定义简单

缺点：容易导致栈溢出，内存资源紧张，内存泄漏；

案例：模拟实现树形结构的遍历

import os #引入文件操作模块

def findFile(file_Path):

      listRs=os.listdir(file_path)#得到该路径下的所有文件夹

      for fileItem in listRs:

           full_path=os.path.join(file_Path, fileItem) #获取完成的文件路径

           if os.path.isdir(full_path)# 判断是否是文件夹

               file_Path(full_path)#如果是一个文件夹 在次去递归

           else:

                print(fileItem)

                pass

           pass

       else:

             return

      pass

匿名函数：

Python中使用lambda关键字创建匿名函数，所谓匿名函数，即这个函数没有名字，不用def关键字创建标准的函数。

使用lambda 关键字去创建函数

没有名字的函数

匿名函数 冒号 后面的表达式有且只有一个

lambda参数1， 参数2， 参数3……，冒号 执行表达式

匿名函数自带return，而这个return的结果就是表达式的结果

如：使用lambda表达式计算两个数和：

test = lambda x, y: x+ y

test(1,3)

test(4,5)

换成普通函数其实就是这样的：

def test(x, y)

return x + y

def computer(x, y):

      return x + y

      pass

对应的匿名函数

M = lambda x, y :x + y

可以通过调用变量M，调用lambda函数

lambda与三元函数：

如下语句：

if a:

    b

else:

    c

能够由以下等效的表达式来模拟

b if a else c

结果 一般条件 一般条件之外的结果

这样的表达式（三元运算）能够放在lambda中，他们能够在lambda函数中来实现选择逻辑

greater = (lambda x, y: x if x > y else y)

greater(3, 5)

greater(6, 2) 

如：

age = 15

print('可以参军‘ if age > 18 else '继续上学')

匿名函数 lambda的缺点：

lambda只能是单个表达式，不是一个代码块，它的设计就是为了满足简单函数的场景，仅能封装有限的逻辑，复杂逻辑实现不了，必须使用def来处理