等腰三角形：

a=' name    '

b=a.strip()去除空格 

lstrip()删除左边的空格

rstrip（）删除右边的空格

capitalize()首字母变大写

id（）内存地址

常用格式化符号：

python数据类型

查数据类型：用type查询
a=10

print（type(a)）

单行注释：#

多行注释：‘’‘’‘’或者'''

如： ‘’‘’‘’

注释为。。。。。。。

‘’‘’‘’

或者

'''

注释。。。。。。。

'''

比较运算是布尔类型的数据（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 （布尔值）

全列插入：

insert into 表名 values( ‘数据1’, ‘数据2’, ‘数据3’……)

部分插入：

insert into 表名 (字段1，字段2 ……）values( ‘数据1’, ‘数据2’, ……),( ‘数据1’, ‘数据2’, ……)

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')]