一入python深似海，从此妹纸是路人

Posted 2023-03-16

一、类的私有属性和方法

_x 单前置下划线,表示私有属性或方法,但是类对象和子类可以访问

__x 双前置下划线,私有属性或方法,只有类对象自己能访问,子类不能访问

__x__ 魔法方法或属性

class Classmate:
    name = lucy
    _age = 20    # 伪私有属性
    __sex = F  # 私有属性
c = Classmate()
print(c._age)    # 对象可以在外部访问伪私有属性
输出：20
# # print(c.__sex)   # 私有属性,在外部不能直接访问
输出：报错

# # 强行获取私有属性    对象._类名私有属性名
print(c._Classmate__sex)
输出：F
print(c.name)
输出：lucy

怎么通过合理地手段获取私有属性或方法?

---解决方案:定义公有方法,在公有方法里去访问这个私有属性或调用私有方法即可

class Classmate:
    def __init__(self):
        self.__name = rose
    def __func(self):  # 私有方法
        print(这是私有方法)
    def funa(self):  # 公有方法
        print(嘿嘿)
        print(self.__name)
        self.__func()
c = Classmate()
# c.__func()    # 直接调用--报错
c.funa()
输出：嘿嘿
     rose
     这是私有方法

二、继承

继承的语法

class 类名(父类名):

pass

1.不使用继承

class  Person:
    def sing(self):
        print(唱歌)
    def dance(self):
        print(跳舞)
p = Person()
p.sing()
p.dance()
输出：唱歌
     跳舞

2、使用继承

class  Mother:
    def sing(self):
        print(唱歌)
    def dance(self):
        print(跳舞)
class Rose(Mother):
    pass
r = Rose()
r.sing()
r.dance()
输出：唱歌
      跳舞

例：

class Father:
def init(self, name, age, property1):
        self.name = name
        self.age = age
        self.property1 = property1
    def diao_cha(self):
        print(fself.name是个富翁,年龄是self.age岁,有财产self.property1万)
class  Child(Father):
    pass
p = Child(follow heart, 20, 100)
p.diao_cha()
输出：follow heart是个富翁,年龄是20岁,有财产100万

三、继承的传递和重写、扩展

1.继承的传递 ---- 接力赛

class Animal:                         # 爷爷
    def __init__(self, name):
        self.name = name
    def eat(self):
        print("吃--")
    def drink(self):
        print("喝--")
        
class Dog(Animal):                   # 爸爸辈
    def bark(self):
        print(fself.name会汪汪叫)   

class Black(Dog):                   # 儿子
    def sa_jiao(self):
        print(f"self.name会撒娇")     
# # 创建一个对象
black = Black(小黑)
black.sa_jiao()
输出：小黑会撒娇

2.重写 ---- 覆盖写

例1：

class Father:
    def myMethod(self):
        print(老爸的学习方法)
class Child(Father):
    def myMethod(self):
        print(儿子的学习方法)
c = Child()
c.myMethod()

例2：

class ZuBei():
    def mi_fang(self):
        print(祖传火锅秘方)
class You(ZuBei):
    def mi_fang(self):
        print(研发出全新的火锅秘方)
you = You()
you.mi_fang()

3.扩展 --- 保留原来的，在原来的基础上拓展

扩展父类 ---本质是调用父类的方法

• 法1：父类名.方法名(self)
• 法2：super().父类方法

class ZuBei():
    def mi_fang(self):
        print(祖传火锅秘方)
class You(ZuBei):
    def mi_fang(self):
        # 法一
        # ZuBei.mi_fang(self)
        # 法二
        super().mi_fang()
        print(研发出升级火锅秘方)
you = You()
you.mi_fang()

四、多继承

子类可以拥有多个父类，并且具有所有父类的属性和方法

多继承的语法： class 类名(父类1,父类2...)

class Dad:
    def work(self):
        print(积累了很多的工作经验)
class Mom:
    def housework(self):
        print(拥有超多的家务经验)
class Child(Dad,Mom):
    pass
c = Child()
c.work()
c.housework()

两个父类有同名方法，继承调用时怎么办？

class Dad(object):
    def play(self):
        print(爸爸休闲时喜欢钓鱼)
class Mom:
    def play(self):
        print(妈妈休闲时喜欢打牌)
class Child(Mom,Dad):    # 继承：就近原则
    pass
c = Child()
c.play()
print(Child.__mro__)   # 确定Child类对象调用方法的顺序

class Dad(object):
    def play(self):
        print(爸爸休闲时喜欢钓鱼)
class Mom:
    def play(self):
        print(妈妈休闲时喜欢打牌)
class Child(Mom,Dad):    # 继承：就近原则
    def play(self):

父类的扩展

Dad.play(self)
        super().play()    # 用super()调用时，调用依据继承顺序来
        print(孩子休闲时喜欢玩游戏)
c = Child()
c.play()

五、多态

多态：多种形态

print(1 + 1) # + 表示加法

print(hello + python) # 字符串的拼接

多态性：一种调用方式，不同的执行结果

----可以定义一个统一的接口，传入不同类型的值，但是调用逻辑一样，执行结果不一样

class Duck(object):
    def fly(self):
        print(鸭子在水里飞起来了)
class Swan(object):
    def fly(self):
        print(天鹅在空中翱翔)
class Plan(object):
    def fly(self):
        print(飞机在机场隆隆地起飞了)
# duck = Duck()
# duck.fly()
# swan = Swan()
# swan.fly()
# plan = Plan()
# plan.fly() 
# 定义一个统一的接口
def func(obj):
    obj.fly()
duck = Duck()
swan = Swan()
plan = Plan()
func(duck)
func(swan)
func(plan)

六、__new__

实例化一个对象

对象名 = 类名() 到底怎么创建出来的？

__new__()有两个作用：

1.在内存中为对象分配空间

2. 返回对象的引用，返回值引发__init__()的调用

实例化一个对象，真正第一个调用的是__new__()方法

class Person(object):
    def __init__(self):
        print(这是init方法)
    def __new__(cls, *args, **kwargs):    # cls作为第一个参数 class
        print(这是new方法中的cls,cls)
        print(这是new方法)
        # return object.__new__(cls)    # 创建对象
        # return super().__new__(cls)
p = Person()

class Iphone(object):
    def __new__(cls, *args, **kwargs):
        print(这是new中cls,cls)
        print(创建对象,分配空间)
        ins = super().__new__(cls)
        print(这是new中的ins,ins)
        return ins
    def __init__(self):
        print(这是init中的self,self)
        print(手机初始化)
print(这是类,Iphone)
pho = Iphone()
print(这是实例化对象,pho)

class A:
    pass
a = A()
print(a)

eval（) 去掉引号

#一入python深似海，从此妹纸是路人

1.什么事编程，什么事编程语言？

• 编程：用代码编写程序
• 编程语言：用哪种语法规则来编写程序

a = 10 => 0101010(exe)

2.编程语言分类

1.编译型：C，GO

一次性把源代码进行翻译

特点：执行效率很高，平台依赖性一般比较高

2.解释型 ：javascript，python，ruby

逐行的对源代码进行翻译和运行

特点：执行效率相对较低，源代码一般无法加密，平台的依赖性不高

3.什么是python？优缺点？

python是一个叫龟叔的荷兰老头写的（89年）

擅长：

• 1.爬虫
• 2.自动化

• 3.科学计算
• 4.人工智能

一、print()

字符串：用引号把内容引起来的

三引号： 打印时原样输出引号里的内容，并且不会改变设置的格式

print("hello"
       "world")   
输出：helloworld

print("""hello
    world""")
输出：hello
    world

二、标志符和变量

1、标志符：凡是要取名字的，都属于标志符的范围----老祖宗

命名规范：----约定俗成

• 1）由数字、字母和下划线组成；
• 2）不能数字开头
• 3）不能与关键字重名

严格区分大小写的

"程序是从上往下执行"

查看关键字

import keyword
print(keyword.kwlist)

2、变量 （不介意写成中文）

变量：会变化的量

作用：存储数据

变量的定义：变量名 = 值 # 赋值

• 1） 变量的名字
• 2） 保存的数据
• 3） 数据的类型
• 4） 内存地址

名字 = yes diezi = 猪肉 print(diezi) 输出：猪肉 diezi = 青菜 print(diezi) 输出：青菜

变量的命名规范：

• 大驼峰：每个单词首字母大写，MyName
• 小驼峰: 第二个（含）以后的单词首字母都大写，如myName
• 下划线: my_name

XueXiao = 第一中学
print(XueXiao)
输出：第一中学

查看数据类型

print(type(XueXiao)) 
输出：<class str> 字符串

查看内存地址

print(id(XueXiao))  
输出：1582019073296    

xueXiao = 第二中学
print(xueXiao)
输出：第二中学

xue_xiao = 第三中学
print(xue_xiao)
输出：第三中学

三、数值类型

数值类型：

• 1.整数 int
• 2.小数，浮点数 float
• 3.布尔型 bool
• 4.复数complex

举例：

整数 int() ：

浮点数 float(): 8.8,9.9

print(type(4.0))  
输出： <class float>

科学计数法

print(3.1E5)  
输出：3.1*10^5
print(type(3.1E5))   
输出：<class float>

布尔序列

"凡是要判断的，它的结果一定是布尔序列：True、False"

print(True) print(type(True)) 输出：<class bool>

布尔值可以当做整数来对待，True 1 False 0

print(True + 1) print(False + 1)

复数 complex z = a + bj

1 + x^2 = 0 ----在实数范围内无解

# 虚数 j^2 = -1

print(1+2j)

四、序列类型

1.字符串

用引号引起来，可以是单引号 也可以双引号

name1 = "haha"
print(name1)
print(type(name1))  
输出：haha
      <class str>

s1 = 10
print(s1,type(s1))  
输出：<class str>

n1 = 10
print(10,type(n1))  
输出：<class int>

字符串三引号：原样输出引号里的内容，不改变内部格式

hh = """hello
     world"""
print(hh)
输出：hello
     world

"字符串规则:单包双或双包单"

print("hello world")
输出：hello world
print(hell\\o world)

2.列表

lie_biao = [1, 2, 3]  
print(type(lie_biao))
输出：<class list>

3.元组

yuan_zu = (1, 2, 3)
print(type(yuan_zu)) 
输出：<class tuple>

4.集合

ji_he = 1, 2, 3
print(type(ji_he)) 
输出：<class set>

5.字典

zi_dian = name:xiyun,gender:F
print(type(zi_dian))  
输出：<class dict>