python基础自学 一周

#测试全局变量，局部变量

a = 3   #全局变量

def test01():
    b = 4   #局部变量
    print(b)
    # 如果直接对a赋值、则这里会自动默认为局部变量，若想用全局，则用global声明
    global a
    a = 300
    print(a)

test01()
print(a)

print(locals())     #打印输出的局部变量
print(globals())    #打印输出的全局变量
#print(b)   b局部变量

print("*******************1.测试参数的传递**********************")
print("********传递可变对象********")
""""
测试参数的传递
传递可变对象（传递的是同一个对象。不是值。相当于c语言的指针）
"""

a1 = [10,20]

print(id(a1))   #2252631007944
print(a1)       #[10, 20]

def test01(m):
    print(m)    #[10, 20]
    m.append(30)
    print(id(m))    #2252631007944

test01(a1)
print(a1)   #[10, 20, 30]

print("********3.传递不可变对象********")
""""
传递不可变对象的引用
传递参数是不可变对象（例如：int，float，字符串，元祖，布尔值），实际传递的
还是对象的引用。在“赋值操作”时，由于不可变对象无法修改，系统会新创建一个对象
"""
a3 = 100
print(id(a3))       #a3的地址：140734343966448
def f1(n):
    print(id(n))    #传递进来的是a的地址：140734343966448
    n = n + 20
    print(id(n))    #n的赋值后的地址：140734343967088，由于a是不可变对象，所以创建新的对象n
    print(n)        #120
f1(a3)
print(a3)           #100

print("*******************4.测试浅拷贝和深拷贝**************************")
""""
浅拷贝：不考贝子对象的内容，只是拷贝子对象的引用
深拷贝：会连子对象的内存也全部拷贝一份，对子对象的修改不会影响源对象
"""
import copy

a4 = [10,20,[5,6]]
b4 = copy.copy(a4)

b4.append(30)
b4[2].append(7)

print("浅拷贝----")
print(a4)
print(b4)

print("深拷贝-----")

a5 = [10,20,[5,6]]
b5 = copy.deepcopy(a5)

b5.append(30)
b5[2].append(7)

print(a5)
print(b5)

'''
参数的几种类型
'''
#1.位置参数。按位置传递的参数
def f1(a,b,c):
    print(a,b,c)
f1(2,3,5)
#f1(2.3)    报错，位置参数不匹配

#2.默认值参数，可以为某些参数设定默认值，传递时是可选的
def f2(a,b,c = 10,d = 20):  #默认值参数必须位于普通位置参数后面
    print(a,b,c,d)
f2(2,5)
f2(5,6,4)

#3.命名参数（关键字参数），可以按照形参的名称传递参数
def f3(a,b,c):
    print(a,b,c)
f3(8,9,10)                  #位置参数
f3(b = 9, a = 8, c = 10)    #命名参数

#4.可变参数。
#1.*param（一个星号），将多个参数收集到一个“元祖”对象中
#2.**param（两个星号），将多个参数收集到一个“字典”对象中
def f4(a,b,*c):
    print(a,b,c)
f4(5,6,4,5,4)       #5,6分别对应a，b剩下的都收集到c元祖中

def f44(a,b,**c):
    print(a,b,c)
f44(5,6,name = "yajg",age = 21) #5,6分别对应a，b剩下的都收集到c字典中
#也可以混合使用，规则一样

#测试lambda表达式、匿名函数

f = lambda a,b,c,d : a + b + c + d
def test01(a,b,c,d):    #lambda和函数一样的性质，没有名字
    print(a+b+c+d)

print(f(2,3,5,4))

g = [lambda a : a * 2,lambda b : b * 3]
print(g[1](6))

h = [test01,test01]     #函数也是对象（万物皆对象）
print(h[0](5,6,4,7))

print("********************2.测试eval()函数******************")
#将字符串str当成有效的表达式来求值并返回计算结果
s2 = "print('abcde')"
eval(s2)

a2 = 10
b2 = 20
c = eval("a2 + b2")
print(c)

dict1 = dict(a = 100, b = 200)
d = eval("a+b",dict1)
print(d)

'''
nonlocal,global关键字
nonlocal    用来声明外层局部变量
global      用来声明全局变量
'''
a = 100
def outer():
    b = 10
    def inner():
        global a    #声明全局变量
        nonlocal b  #声明外部函数的局部变量，只有声明了才能修改
        a = 200
        b = 20
    inner()
    print(b)
    print(a)
outer()

#创建一个类
class Student:      #类名一般首字母大写，多个单词采用驼峰原则

    def __init__(self,name,score):  #__init__(self,.....)构造方法
        self.name = name
        self.score = score

    def say_score(self):    #self必须位于第一个参数
        print("{0}的分数是：{1}".format(self.name,self.score))

s1 = Student("杨jie",18)
s1.say_score()

print(dir(s1))      #dir(obj)可以获得对象的所有属性、方法

print(s1.__dict__)  #对象的属性字典

print(isinstance(s1,Student))   #判断对象是不是“指定类型”

stu2 = Student
s2 = stu2("gao",200)

s2.say_score()

class Man:
    pass    #表示空

class Student:

    company = "SX"  #类属性
    count = 0   #类属性

    def __init__(self,name,score):
        self.name = name
        self.score = score
        Student.count = Student.count + 1

    def say_score(self):
        print("我的公司是：",Student.company)
        print(self.name,"的分数是：",self.score)

    @classmethod        #类方法
    def testclass(cls):
        #print(self.score)  类方法。静态方法不能调用实例变量和实例方法
        print("lei")

    #python中允许定义与“类对象”无关的方法，称为“静态方法”，只不过通过类调用
    @staticmethod
    def teststatic():
        pass

s1 = Student("张三",60)
s1.say_score()
s2 = Student("zf",20)

print("一共创建了{0}个对象。".format(Student.count))
Student.testclass()

#折构方法
class Person:
    def __init__(self):
        print("销毁对象{0}".format(self))

p1 = Person()
p2 = Person()
del p2
print("程序结束")

#测试可调用方法__call__()

class SalaryAccount:

    def __call__(self,salary):
        print("算工资了！")
        yearSalary = salary * 12
        daySalary = salary // 22.5
        hourSalary = daySalary // 8

        return dict(yearSalary = yearSalary, daySalary = daySalary, hourSalary = hourSalary)

s = SalaryAccount()
print(s(12000))

#测试方法的动态性(万物皆对象）

class Person:

    def work(self):
        print("努力上班！")

def play_game(s):
    print("{0}在玩游戏".format(s))

def work2(s):
    print("好好工作！")

Person.play = play_game;
p = Person()
p.work()
p.play()

Person.work = work2

p.work()

print("******************测试私有属性*********************")
class Employee:

    __company = ""  #私有属性

    def __init__(self,name,age):
        self.name = name
        self.__age = age    #加__（双下划线）的默认为私有属性

    def __work(self):       #私有方法
        print("haohaogongzuo")
        print("年龄{0}".format(self.__age))   #自己可以调用

e = Employee("jie",25)
print(e.name)
#print(e.age)   私有属性不可直接访问
print(e._Employee__age)     #访问私有属性。相当于变了个名字
e._Employee__work()         #访问私有方法

#测试@property的用法
#将方法调用变成属性调用，不能设置属性

class Employee1:

    @property
    def salary(self):
        print("run...")
        return 10000

emp1 = Employee1()
#emp1.salary()
print(emp1.salary)

print("*********************测试@property装饰器的用法***************")
class Employee:

    def __init__(self,name,salary):
        self.__name = name
        self.__salary = salary

    @property
    def salary(self):
        return self.__salary

    @salary.setter
    def salary(self,salary):
        if 1000 <= salary <= 50000:
            self.__salary = salary
        else:
            print("录入错误，薪水在1000--50000元之间")

'''
    普通的方法
    def get_salary(self):
        return self.__salary

    def set_salary(self,salary):
        if 1000 < =salary <=50000:
            self.__salary = salary
        else:
            print("录入错误，薪水在1000--50000元之间")
'''
emp = Employee("杨",15000)
#普通的方法
# print(emp.get_salary())
# emp.set_salary(30000)
# print(emp.get_salary())

print(emp.salary)
emp.salary = 50000
print(emp.salary)

#测试继承的基本使用
class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age  #私有属性

    def say_age(self):
        print("年龄！")

    def say_name(self):
        print("我的名字是{0}".format(self.name))

    def __str__(self):  #重写__str__()方法,(相当于java中的toString()方法)
        return self.name

class Student(Person):
    def __init__(self,name,age,score):
        Person.__init__(self,name,age)  #必须显式的调用父类的初始化方法，不然解释器不会去调用
        self.score = score

    def say_name(self):
        print("")
        super().say_name()      #super()，代表父类的定义，而不是父类的对象
        '''重写say_name()方法'''
        print("报告，我的名字是{}".format(self.name))



#Student-->Person-->Object类
print(Student.mro())    #mro方法输出这个类的结构层次

a = Student("jaig",19,99)
a.say_age()
print(a.name)
print(a._Person__age)
print(dir(a))
a.say_name()
print(a)

#多态
class Man:
    def eat(self):
        print("吃饭了！")

class Chinese(Man):
    def eat(self):
        print("用筷子吃饭！")

class English(Man):
    def eat(self):
        print("用刀叉吃饭！")

def Eat(s):
    if isinstance(s,Man):
        s.eat()
    else:
        print("不能吃饭！")

Eat(Chinese())
Eat(English())

#d测试工厂模式
class CarFactory:
    def create_car(self,brand):
        if brand == "奔驰":
            return Benz()
        elif brand == "比亚迪":
            return BYD()
        else:
            return "无法创建！"

class Benz:
    pass
class BYD:
    pass

#建立工厂
factory = CarFactory()
c1 = factory.create_car("奔驰")
c2 = factory.create_car("比亚迪")
c3 = factory.create_car("sf")

print(c1)
print(c2)
print(c3)

#测试单例模式

class MySingleton:

    __obj = None    #类属性
    __init_flag = True

    def __new__(cls,*args,**kwargs):
        if cls.__obj == None:
            cls.__obj = object.__new__(cls)

        return cls.__obj

    def __init__(self,name):

        if MySingleton.__init_flag:
            print("init...")
            self.name = name
            MySingleton.__init_flag = False

a = MySingleton("aa")
b = MySingleton("bb")
print(a)
print(b)