python基础语法第一弹

字符串

• 转义字符
• 格式化
• 内建函数

转义字符

• 用一个特殊的表示出一系列不方便写出的内容，比如回车、换行、退格
• 借助反斜杠字符，一旦字符串中出现反斜杠，则反斜杠后面一个火几个字符表示已经不是原来的意思了，进行了转义
• 在字符串中，一旦出现反斜杠就要加倍小心，可能有转义字符出现
• 不同系统对换行操作不同
  • Windows：\n
  • linux: \r\n

# 可以使用嵌套引号，即外层使用双引号
# 转义字符
# \ == 
# \\ == \
s = "let's go"
a = "c:\\uers"
print(s)
print(a)
# 回车换行符
c = "i love china"
b = "i love \n china"
print(c)
print(b)
# 如果反斜杠太多，用r
d = r"C:\nouw"
print(d)

# 三重引号字符
d = """
enheng 
hhhh
dangdang
"""
print(d)

enheng 
hhhh
dangdang

字符串的格式化

• 把字符串按照一定格式打印或者填充
• 格式化由两种方法
  • 利用百分号%
  • 利用format函数

s = "** 您好，学校开课了"

百分号

• %d:应该放一个整数
• %s:字符串

s = "i love %s"
# 直接打印百分号
print(s)

i love %s

# 在后面用百分号进行格式化替换
print("i love %s"%"china")

i love china

print(s%"husi")

i love husi

b = "i am %d years old"
print(b%18)

i am 18 years old

# 如果出现多个占位符，则相应占位符可用括号括起来
s = "i am %s,i am %d years old"
print(s%("husi",18))

i am husi,i am 18 years old

format函数格式化

• 直接用format函数进行格式化
• 推荐使用
• 在使用上，以{}和：代替%，后面用format带参数完成

s = "i love {}".format("china")

a = "i am {1} years old,i love {0} and i am {1} years old".format("china",18)
print(a)
print(s)

i am 18 years old,i love china and i am 18 years old
i love china

None

• 表示什么都没有
• 如果函数没有返回值，可以返回None
• 用来占位
• 用来解除变量的绑定

表达式

• 由一个或者几个数字或者变量和运算符组合成的一行代码
• 通常会返回一个结果

运算符

• 由一个以上的值经过变化得到新值的过程就叫运算
• 用于运算的符号叫运算符
• 运算符的分类
  • 算数运算符
  • 比较或关系运算符
  • 位运算
  • 赋值运算符
  • 成员运算符
  • 身份运算符
  • 逻辑运算符

算数运算符

• 进行算数运算的符号

# + - 跟正常算术运算符一模一样
# 乘：*
# 除号：/
# %取余运算:只会得到余数
s = 9 % 4
print(s)
# // 表示取商运算，也叫地板除
s = 9 // 4
print (s)
# ** 表示幂运算
s = 9**4
print(s)

1
2
6561

比较运算符

• 对两个变量或者值进行比较
• 比较的结果是布尔值，即True/False

# ==：等于号
a = 3**4
# 先运行a是否等于80，然后再将这个判断的布尔值赋给bz
b = a == 80
print(b)

# != 不等于
print(9 != 8)
# >= 大于等于

False
True

赋值运算符

# =：赋值
# += :是缩写
a += 7 # a = a+7 的缩写
# -=， ×=，/=等等都是缩写

逻辑运算符

• 对布尔值进行计算的符号
• and
• or
• not 逻辑非
• python中逻辑运算是没有异或运算的
• 逻辑规则：
  • and看作乘法，or看作加法
  • True看作1，False看作0
  • 最后结果如果是0则会false，否则为True
• 逻辑运算的短路问题
  • 按照运算顺序计算，一旦能够确定整个式子的值，则不再计算后面的了

# 逻辑运算符案例
a = True
b = False
c = True

d = a and b or c # d=1*0+1
print(d)

True

# 逻辑运算的短路案例

# a 的值一定是True,则运行到or的时候，整个表达式不再向后计算
a = True or xxxxx

成员运算

• 用来检测一个变量是否是另一个变量的成员
• in
• not in

# 案例
l = [1,2,3,45,6]
a = 8
b = a in l
print(b)
print(a not in l)

False
True

身份运算

• is: 用来检测两个变量是否是同一个变量
  • 语法就是 var1 is var2
• is not :不是同一个变量

s = 1
c = 2
print(s is c)

False

运算符的优先级

• 括号具有最高优先级

程序结构

• 顺序
• 分支
• 循环

23 分支 for循环

三大结构

• 顺序
• 分支
• 循环

分支

• 分支的基本语法

  if 条件表达式:
  语句1
  语句2

• 条件表达式就是计算结果必须为布尔值的表达式

• 表达式后面的冒号不能少

• 注意if后面出现的语句，如果属于if语句块，则必须同一个缩进等级

• 条件表达式结果为True执行if后面的缩进的语句块

# 案例
age = 20
if age < 18:
    print("不一起玩")
    print("nizou")
elif age > 18:
    print("开课了")

开课了

双向分支

• if…else…语句

  if 条件表达式：
  语句1
  语句2
  else：
  语句1
  语句2

• 双向分支有两个分支，当程序执行到这个语句的时候，一定会只执行if或else中的一个

• 缩进问题：if和else是一个层级，其余语句是一个层级

gender = input("请输入性别:")
print("你输入的性别是：{0}".format(gender))

if gender == "man":
    print("赶紧来敲代码")
else:
    print("去玩吧")

请输入性别:nan
你输入的性别是：nan
去玩吧

# 考试成绩
score = input("请输入成绩")
score = int(score) # input返回值的类型是字符串，需要把str转为int
if score >= 90:
    print("A")
elif score >= 80:
    print("B")   
elif score >= 70:
    print("C")
elif score >= 60:
    print("D")
elif score < 60:
    print("E")

请输入成绩90
A

多路分支

• 很多分支

  • if 条件表达式：
    语句1
    elif 条件表达式:
    语句1
    else

• elif可以有很多

• else可以没有

if语句其他：

• if语句可以嵌套使用，但也不推荐
• python没有switch-case语句

循环语句

• 一遍一遍去循环你的语句
• 分类
  • for循环
  • while循环

for循环

• for循环

   for 变量 in 序列
       语句1
       语句2
  

• 列表就是一列数字或其他值

list1 = ["zahngsan","wangwu","zhaoliu"]
for name in list1:
    print(name)

zahngsan
wangwu
zhaoliu

list1 = ["zhangsan","wangwu","zhaoliu"]
for name in list1:
    print(name)
    if name == "zhangsan":
        print("i love you,{0}".format(name))
    else:
        print("zoukai")

zhangsan
i love you,zhangsan
wangwu
zoukai
zhaoliu
zoukai

range介绍

• 生成一个数字序列
• 具体范围可以设定

# 打印1-10
# 左包括，右不包括#randint是特例，左右都包含
for i in range(1,11):
    print(i)

1
2
3
4
5
6
7
8
9
10

for else 语句

• 当for循环结束的时候，会执行else语句
• else语句是可选语句

# for-else语句
# 打印列表中的同学
# 如果没有在列表中，或者列表结束了，我们需要打印提示语句
list1 = ["zhangsan","wangwu","zhaoliu"]
for name in list1:
    print(name)
    if name == "zhangsan":
        print("i love you,{0}".format(name))
    else:
        print("zoukai")
else:
    print("hhh")

zhangsan
i love you,zhangsan
wangwu
zoukai
zhaoliu
zoukai
hhh

for循环之break，continue，pass

• break:无条件结束整个循环,简称循环猝死
• continue：无条件结束本次循环，重新进入下一轮
• pass：表示略过

# 在1-10的数字中，寻找数字7，一旦找到，打印出来
# for循环中的变量表示：一般用i,k,m,n或者index,idx,item之类
for i in range(1,11):
    if i == 7:
        print("find it")
        break
    else:
        print(i)

1
2
3
4
5
6
find it

# 在1-10的数字中，寻找偶数，一旦找到，打印出来
# for循环中的变量表示：一般用i,k,m,n或者index,idx,item之类
for i in range(1,11):
    if i%2 == 1:
        continue
    else:
        print("{}是偶数".format(i))

2是偶数
4是偶数
6是偶数
8是偶数
10是偶数

# pass一般用于占位
for i in range(1,11):
    pass

24 while 函数

while循环

• 一个循环语句

• 表示当某条件成立的时候就循环

• 不知道具体循环次数，但能确定循环的成立条件的时候使用while循环

• while语法：

    while 条件:
        语句块
    # 另外一种表达
    while 条件表达式:
        语句块
    else：
        语句块
  

# 如果说年利率6.7%，本利每年翻滚，则多少年之后本钱会翻倍
moneny = 10000
year = 0
while moneny < 20000:
    moneny = moneny *(1+0.067)
    year += 1 #year = year + 1
    print("第{0}年，拿了{1}钱".format(year,moneny))

第1年，拿了10670.0钱
第2年，拿了11384.89钱
第3年，拿了12147.677629999998钱
第4年，拿了12961.572031209998钱
第5年，拿了13829.997357301068钱
第6年，拿了14756.607180240238钱
第7年，拿了15745.299861316334钱
第8年，拿了16800.23495202453钱
第9年，拿了17925.85069381017钱
第10年，拿了19126.88269029545钱
第11年，拿了20408.383830545245钱

moneny = 10000
year = 0
while moneny < 20000:
    moneny = moneny *(1+0.067)
    year += 1 #year = year + 1
    print("第{0}年，拿了{1}钱".format(year,moneny))
else:
    print("zhongyufanbeil")

第1年，拿了10670.0钱
第2年，拿了11384.89钱
第3年，拿了12147.677629999998钱
第4年，拿了12961.572031209998钱
第5年，拿了13829.997357301068钱
第6年，拿了14756.607180240238钱
第7年，拿了15745.299861316334钱
第8年，拿了16800.23495202453钱
第9年，拿了17925.85069381017钱
第10年，拿了19126.88269029545钱
第11年，拿了20408.383830545245钱
zhongyufanbeil

函数

• 代码的一种组织形式
• 一个函数一般完成一项特定的功能
• 函数使用
  • 函数需要先定义
  • 使用函数叫函数调用

# 定义一个函数
# 只是定义的话不会执行
# 括号内可以有参数，冒号不能少
# 函数内所有代码要缩进
def fun():
    print("我是一个函数")
    print("我要完成一定的功能")
    print("我结束了")

# 调用
fun()

我是一个函数
我要完成一定的功能
我结束了

函数的参数

• 参数：负责给函数传递一些必要的数据或者信息
  • 形参：在函数定义的时候用到的参数没有具体值，只是一个占位的符号
  • 实参：在调用函数的时候输入的值
• 返回值：函数的执行结果
  • 如果没有return，就会默认返回一个return
  • 函数一旦执行return语句，则会无条件返回，结束

# 参数的定义和使用
# 调用的时候，会用p的值代替函数中所有的person
def hello(person):
    print("{0},nihao".format(person))

p = "xiaoming"
hello(p)

xiaoming,nihao

# return语句的基本使用
# 函数打完招呼后返回一句话
def hello(person):
    print("{0},nihao".format(person))
    return"我已经和{}打过招呼了，但是{}不理我".format(person,person)
p = "xiaoming"
rst = hello(p)
print(rst)

xiaoming,nihao
我已经和xiaoming打过招呼了，但是xiaoming不理我

def hello(person):
    print("{0},nihao".format(person))
    return"hhh"
    return"我已经和{}打过招呼了，但是{}不理我".format(person,person)
p = "xiaoming"
rst = hello(p)
print(rst)

xiaoming,nihao
hhh

# 99乘法表
for h in range(1,10):
    for l in range(1,h+1):
        #print默认打印完自动换行
        print(h*l,end=" ")
    print()
    

1 
2 4 
3 6 9 
4 8 12 16 
5 10 15 20 25 
6 12 18 24 30 36 
7 14 21 28 35 42 49 
8 16 24 32 40 48 56 64 
9 18 27 36 45 54 63 72 81 

# 定义函数打印乘法表
def printline(h):
    for l in range(1,h+1):
        print(h*l,end=" ")
    print("")
    
for h in range(1,10):
    printline(h)

1 
2 4 
3 6 9 
4 8 12 16 
5 10 15 20 25 
6 12 18 24 30 36 
7 14 21 28 35 42 49 
8 16 24 32 40 48 56 64 
9 18 27 36 45 54 63 72 81 

参数

• 参考资料：https：//www.cnblogs.com/bingabcd/p/6671368.html
• python参考资料：headfirst python->零基础入门学习python->腾讯公开免费课
• 参数分类
  • 普通参数
  • 默认参数
  • 关键字参数
  • 收集参数
• 普通参数

  • 参见上例

  • 定义的时候直接定义变量名

  • 调用的时候直接把变量或者值放入指定的位置

      def 函数名(参数1.参数2）
          函数体
      #调用
      函数名（value1，value2）
      # 调用的时候，具体值参考的是位置，按位置赋值
    

• 默认参数

  • 形参带有默认值

  • 调用的时候，如果没有对相应形参赋值，则使用默认值

      def fun_name(p1=v1,p2=v2)
          func_block
      # 调用
      func_name()
      
      #调用2
      value1 = 100
      value2 = 200
      func_name(value1,value2)
    

# 默认参数示例
# 报名函数，需要知道学生性别
def reg(name,age,gender = "male"):
    if gender == "male":
        print("{}is{},and he is a goood student".format(name,age))
    else:
        print("{}is{},and she is a goood student".format(name,age))
reg("xiaoming",21)
reg("xiaohua",21,"nv")

xiaomingis21,and he is a goood student
xiaohuais21,and she is a goood student

关键字参数

• 语法

   def func(p1=v1,p2=v2):
       func_body
      
   # 调用函数：
   func(p1=value1,p2=value2)
  

• 比较麻烦，但也有好处：

  • 不容易混淆，一般实参和形参只是按照位置一一对应即可，容易出错
  • 使用关键字参数，可以不考虑参数的位置

def stu(name,age,addr):
    print("i am a student")
    print("i am {0},{1} years old,live in{2}".format(name,age,addr))
stu("husi",18 ," hunan")

i am a student
i am husi,18 years old,live in hunan

收集参数

• 把没有位置，不能和定义时的参数位置相对应的参数，放入一个特定的数据结构中

• 语法

    def func(*arg):
       func_body
       
    # 调用
    func(p1,p2,p3)
  

• 参数名args不是必须这么写，但是推荐，约定俗成

• 参数名args前需要有星号

• 收集参数可以和其他参数共存

# 收集参数代码
# 函数模拟一个学生进行自我介绍，但是具体内容不清粗
# 把args看作一个list
def stu(*args):
    print(type(args))
    for i in args:
        print(i)

stu("husi",18,"hunan","i love china")
stu("xingsu",17)

<class 'tuple'>
husi
18
hunan
i love china
<class 'tuple'>
xingsu
17

# 收集参数可以不带任何实参调用，此时收集参数为空tuple
stu()

<class 'tuple'>

收集参数之关键词收集参数

• 只有关键字参数按字典格式存入收集参数 #如果使用关键字参数格式调用，会出现问题

• 语法

    def func( **kwargs)
       func_body
   # 调用
    func(p1=v1,p2=v2)
  

• kwargs约定俗成

• 调用的时候，把多余的关键字参数放入kwargs

• 访问kwargs需要按照字典格式访问

def stu( **kwargs):
    print(type(kwargs))
    for k,v in kwargs.items():
        print(k,":",v)
        
stu(name="xingsu", age=19, live="hunan", work="student", add="china")
print("")
stu(name = "hh")

<class 'dict'>
name : xingsu
age : 19
live : hunan
work : student
add : china

<class 'dict'>
name : hh

stu()

<class 'dict'>

收集参数混合调用的顺序问题

• 收集参数，关键字参数，普通参数可以混合使用
• 使用规则就是普通参数和关键字参数优先
• 定义的时候一般找普通参数，关键字参数和收集参数tuple，收集参数dic

# 收集参数混合调用案例
# stu模拟学生自我介绍
def stu(name,age,hobby="none",*args,**kwargs):
    print("hello,大家好")
    print("i am {0},i am {1}years old".format(name,age))
    if hobby =="none":
          print("i hve no hobby")
    else:
          print("my hobby is {0}".format(hobby))
    print(" ")
    for i in args:
          print(i)
          
    print(" ")
    for k,v in kwargs:
          print(k,"_",v)

name = "xiaoming"
age = 18
stu(name,age,hobby="swimming")

hello,大家好
i am xiaoming,i am 18years old
my hobby is swimming

收集参数的解包问题

• 把参数放入list或者字典中，直接把list/dict的值放入收集参数中

def stu(*args):
    print("hhhh")
    for i in args:
        print(i)
stu("ss",16,"12")

hhhh
ss
16
12

# 返回值
def func_1():
    print("hh")
f = func_1()
print(f)

hh
None

函数文档

• 函数的文档的作用是对当前函数提供使用相关的参考信息
• 文档的写法：
  • 在函数内部开始的第一行使用三引号定义符
  • 一般具有特定的格式
• 文档查看
  • 使用help函数
  • 使用__doc__

def stu(*args):
    """
    zipheshiwendang
    """
    print(" ")

help(stu)
stu.__doc__

Help on function stu in module __main__:

stu(*args)
    zipheshiwendang






'\n    zipheshiwendang\n    '

变量的作用域

• 变量由作用范围限制
• 分类
  • 全局（global）：在函数外部定义
  • 局部(local):在函数内部下定义
• 变量的作用范围：
  • 全局变量：在整个全局范围都有效
  • 全局变量在局部可以使用（即函数内部可以使用函数外部定义的变量)
  • 局部变量在局部范围可以使用
• LEGB原则——只能从里边访问外变
  • L:local:局部作用域
  • E：enclosing function local:外部嵌套函数作用域
  • G：global module：函数定义所在模块作用域
  • B：buildin：python 内置模块作用域

a1 = 100
def fun():
    print(a1)
    a2=99 # 作用范围是fun
    print(a2)
print(a1)
fun()
print(a2) #超出范围。所以不能调用

100
100
99



---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-4-4520a9af0bf8> in <module>()
      6 print(a1)
      7 fun()
----> 8 print(a2) #超出范围。所以不能调用


NameError: name 'a2' is not defined

提升局部变量为全局变量

• 使用global

def fun():
    global b1 
    b1= b1(global)
    print(b1)
    b2=99 # 作用范围是fun
    print(a2)
print(b1)
fun()
print(b2) #超出范围。所以不能调用

  File "<ipython-input-9-ded5163fb2ca>", line 4
    b1= b1(global)
                ^
SyntaxError: invalid syntax

glboals,locals函数

• 可以通过globals和locals显示出全局和局部变量

a = 1

def fun(c,d):
    e = 111
    print("locals={0}".format(locals()))
    print("globals={0}".format(globals()))
    
fun(100,200)

locals={'c': 100, 'd': 200, 'e': 111}
globals={'__name__': '__main__', '__doc__': 'Automatically created module for IPython interactive environment', '__package__': None, '__loader__': None, '__spec__': None, '__builtin__': <module 'builtins' (built-in)>, '__builtins__': <module 'builtins' (built-in)>, '_ih': ['', 'a1 = 100\ndef fun():\n    print(a1)\n    a2=99\n    print(a2)\nprint(a1)', 'a1 = 100\ndef fun():\n    print(a1)\n    a2=99\n    print(a2)\nprint(a1)\nfun()', 'a1 = 100\ndef fun():\n    print(a1)\n    a2=99 # 作用范围是fun\n    print(a2)\nprint(a1)\nfun()\nprint(a2)', 'a1 = 100\ndef fun():\n    print(a1)\n    a2=99 # 作用范围是fun\n    print(a2)\nprint(a1)\nfun()\nprint(a2) #超出范围。所以不能调用', '\ndef fun():\n    b1 = 100\n    print(b1)\n    b2=99 # 作用范围是fun\n    print(a2)\nprint(b1)\nfun()\nprint(b2) #超出范围。所以不能调用', '\ndef fun():\n    global b1 = 100\n    print(b1)\n    b2=99 # 作用范围是fun\n    print(a2)\nprint(b1)\nfun()\nprint(b2) #超出范围。所以不能调用', '\ndef fun():\n    global b1 \n    b1= 100\n    print(b1)\n    b2=99 # 作用范围是fun\n    print(a2)\nprint(b1)\nfun()\nprint(b2) #超出范围。所以不能调用', '\ndef fun():\n    global b1 \n    b1= b1.global\n    print(b1)\n    b2=99 # 作用范围是fun\n    print(a2)\nprint(b1)\nfun()\nprint(b2) #超出范围。所以不能调用', '\ndef fun():\n    global b1 \n    b1= b1(global)\n    print(b1)\n    b2=99 # 作用范围是fun\n    print(a2)\nprint(b1)\nfun()\nprint(b2) #超出范围。所以不能调用', 'a = 1', 'a = 1\nb = 2\n\ndef fun(c,d):\n    e = 111\n    print("locals={}".format(locals()))', 'a = 1\n\ndef fun(c,d):\n    e = 111\n    print("locals={0}".format(locals()))\n    print("globals={0}".format(globals()))\n    \nfun(100,200)'], '_oh': {}, '_dh': ['C:\\Users\\12633'], 'In': ['', 'a1 = 100\ndef fun():\n    print(a1)\n    a2=99\n    print(a2)\nprint(a1)', 'a1 = 100\ndef fun():\n    print(a1)\n    a2=99\n    print(a2)\nprint(a1)\nfun()', 'a1 = 100\ndef fun():\n    print(a1)\n    a2=99 # 作用范围是fun\n    print(a2)\nprint(a1)\nfun()\nprint(a2)', 'a1 = 100\ndef fun():\n    print(a1)\n    a2=99 # 作用范围是fun\n    print(a2)\nprint(a1)\nfun()\nprint(a2) #超出范围。所以不能调用', '\ndef fun():\n    b1 = 100\n    print(b1)\n    b2=99 # 作用范围是fun\n    print(a2)\nprint(b1)\nfun()\nprint(b2) #超出范围。所以不能调用', '\ndef fun():\n    global b1 = 100\n    print(b1)\n    b2=99 # 作用范围是fun\n    print(a2)\nprint(b1)\nfun()\nprint(b2) #超出范围。所以不能调用', '\ndef fun():\n    global b1 \n    b1= 100\n    print(b1)\n    b2=99 # 作用范围是fun\n    print(a2)\nprint(b1)\nfun()\nprint(b2) #超出范围。所以不能调用', '\ndef fun():\n    global b1 \n    b1= b1.global\n    print(b1)\n    b2=99 # 作用范围是fun\n    print(a2)\nprint(b1)\nfun()\nprint(b2) #超出范围。所以不能调用', '\ndef fun():\n    global b1 \n    b1= b1(global)\n    print(b1)\n    b2=99 # 作用范围是fun\n    print(a2)\nprint(b1)\nfun()\nprint(b2) #超出范围。所以不能调用', 'a = 1', 'a = 1\nb = 2\n\ndef fun(c,d):\n    e = 111\n    print("locals={}".format(locals()))', 'a = 1\n\ndef fun(c,d):\n    e = 111\n    print("locals={0}".format(locals()))\n    print("globals={0}".format(globals()))\n    \nfun(100,200)'], 'Out': {}, 'get_ipython': <bound method InteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x00000179D2BC7BA8>>, 'exit': <IPython.core.autocall.ZMQExitAutocall object at 0x00000179D3518630>, 'quit': <IPython.core.autocall.ZMQExitAutocall object at 0x00000179D3518630>, '_': '', '__': '', '___': '', '_i': 'a = 1\nb = 2\n\ndef fun(c,d):\n    e = 111\n    print("locals={}".format(locals()))', '_ii': 'a = 1', '_iii': '\ndef fun():\n    global b1 \n    b1= b1(global)\n    print(b1)\n    b2=99 # 作用范围是fun\n    print(a2)\nprint(b1)\nfun()\nprint(b2) #超出范围。所以不能调用', '_i1': 'a1 = 100\ndef fun():\n    print(a1)\n    a2=99\n    print(a2)\nprint(a1)', 'a1': 100, 'fun': <function fun at 0x00000179D36C1A60>, '_i2': 'a1 = 100\ndef fun():\n    print(a1)\n    a2=99\n    print(a2)\nprint(a1)\nfun()', '_i3': 'a1 = 100\ndef fun():\n    print(a1)\n    a2=99 # 作用范围是fun\n    print(a2)\nprint(a1)\nfun()\nprint(a2)', '_i4': 'a1 = 100\ndef fun():\n    print(a1)\n    a2=99 # 作用范围是fun\n    print(a2)\nprint(a1)\nfun()\nprint(a2) #超出范围。所以不能调用', '_i5': '\ndef fun():\n    b1 = 100\n    print(b1)\n    b2=99 # 作用范围是fun\n    print(a2)\nprint(b1)\nfun()\nprint(b2) #超出范围。所以不能调用', '_i6': '\ndef fun():\n    global b1 = 100\n    print(b1)\n    b2=99 # 作用范围是fun\n    print(a2)\nprint(b1)\nfun()\nprint(b2) #超出范围。所以不能调用', '_i7': '\ndef fun():\n    global b1 \n    b1= 100\n    print(b1)\n    b2=99 # 作用范围是fun\n    print(a2)\nprint(b1)\nfun()\nprint(b2) #超出范围。所以不能调用', '_i8': '\ndef fun():\n    global b1 \n    b1= b1.global\n    print(b1)\n    b2=99 # 作用范围是fun\n    print(a2)\nprint(b1)\nfun()\nprint(b2) #超出范围。所以不能调用', '_i9': '\ndef fun():\n    global b1 \n    b1= b1(global)\n    print(b1)\n    b2=99 # 作用范围是fun\n    print(a2)\nprint(b1)\nfun()\nprint(b2) #超出范围。所以不能调用', '_i10': 'a = 1', 'a': 1, '_i11': 'a = 1\nb = 2\n\ndef fun(c,d):\n    e = 111\n    print("locals={}".format(locals()))', 'b': 2, '_i12': 'a = 1\n\ndef fun(c,d):\n    e = 111\n    print("locals={0}".format(locals()))\n    print("globals={0}".format(globals()))\n    \nfun(100,200)'}

eval（）函数

• 把一个字符串当成一个表达式来执行

• 语法：

    eval(string_code,globals=None,locals=None)
  

exec()函数

• 跟eval功能类似，但是不返回结果，语法一样

x = 100
y = 200
z = eval("x+y")
print(z)

300

x = 100
y = 200
z = exec("x+y")
print(z)

None

递归函数

• 函数直接或间接调用自身
• 好处：简洁欸，理解容易
• 缺点：对递归深度由限制，消耗资源大
• python对递归深度有限制，超过限制报错
• 写递归要注意结束条件

# 递归调用深度限制代码

x = 0
def fun():
    global x
    x += 1
    print(x)
    fun()
fun()

# 斐波那契数列
#f(n)= f(n-1)+f(n-2)
def fib(n):
    if n == 1:
        return 1
    if n == 2:
        return 1
    
    return fib(n-1)+fib(n-2)
fib(5)

5

内置数据结构（变量类型)

• list
• set
• dict
• tuple

list

• 有顺序的数据的组合
• 创建列表
  • 空列表

l1 = []

列表常用操作

• 访问

  • 使用下标操作（索引)
  • 列表的位置是从0开始的

• 分片操作

  • 对列表进行任意一段的截取
  • l[ : ]

l = [2,45,6,7,8,9,7]
l[2]
l[6]
print(l[0])
l[1:5]# 包含左不包含右
# 下标值可以为空，如果不写，左边下标值默认为0，右边下标值为最后数加1，即表示截取到
#最后一个数据
l[ : ]
l[:3]
l[5:]

2





[9, 7]

# 分片可以控制增长幅度，默认增长幅度为1
print(l[1:6:1])
print(l[1:6:2])
# 下标值增长幅度可以为负数
# 为负数，表明顺序是从右往左
# 规定数组最后一个数字的下标是 -1

# 默认分片总是从左向右截取，即左边的值一定要<右边
print(l[-2:-5])

print(l[-5:-2])

print(l[-3:-6:-1])

[45, 6, 7, 8, 9]
[45, 7, 9]
[]
[6, 7, 8]
[8, 7, 6]

分片操作时生成一个新的list

• 内置函数id，负责显示一个变量或者数据的唯一确定编号

a = 100
b = 200
print(id(a))
print(id(b))

c = a
print(id(c)) # a和c是一样的

a = 101
print(a)
print(c)

140733582932832
140733582936032
140733582932832
101
100

l1= [1,34,5.46,47,78,6]
ll = l1[:]
lll = ll
print(id(l1))
print(id(ll))

print(id(lll))

1622749075848
1622749886408
1622749886408

# 汉诺塔
def hano(n,a,b,c):
    if n ==1:
        print(a,"-",c)
        return None
    if n ==2:
        print(a,"-",b)
        print(a,"-",c)
        print(b,"-",c)
        return None
    # 把 n-1个盘子，从a塔借助于c塔，挪到b塔上去
    hano(n-1,a,c,b)
    print(a,"-",c)
    # 把n-1个盘子，从b塔借助于a塔，挪到c塔上
    hano(n-1,b,a,c)
    
    # 顺序就是谁借谁移到谁上去
    
a = "A"
b = "B"
c = "C"

n = 2
hano(n,a,b,c)

A - B
A - C
B - C

list

• del:删除

l = [1,3,4,78,67,89]
del l[1]  # 原地删除，在list当中直接删除
print(l)

[1, 4, 78, 67, 89]

列表相加

• 使用加号连接两个列表

a = [1,34,5,6,57,6,7]
b = [2,78,909090,7890780]
c = a + b  # 还可以使用乘号
print(c)

[1, 34, 5, 6, 57, 6, 7, 2, 78, 909090, 7890780]

# 成员资格运算:判断一个元素是否在list里边
a = [1,34,5,6,57,6,7]

b = 121212
c =b in a  # not in
print(c)

False

列表的遍历

• for
• while

a = [1,234,4,35,4,35]

for i in a:
    print(i)

1
234
4
35
4
35

b = ["i love china"]
for i in b:
    print(i)

i love china

# range

# in后面的变量要求是可以可迭代的内容
for i in range(1,10):
    print(i)

1
2
3
4
5
6
7
8
9

# 一般情况下不用while访问list

# 双层列表循环
#为嵌套列表/双层列表
a = [[1,3],[2,4],[3,6]]
for k,v in a:
    print(k,"-",v)

1 - 3
2 - 4
3 - 6

a = [[1,3,4],[2,4,5],[3,6,6]]
for k,v,w in a:
    print(k,"-",v,"-",w)

1 - 3 - 4
2 - 4 - 5
3 - 6 - 6

列表内涵：list content

• 通过简单的方法创作列表

# for 创建
a = [1,2,3,4]
b = [i for i in a]
print(b)

[1, 2, 3, 4]

a = [1,2,3,4]
b = [i*10 for i in a]
print(b)

[10, 20, 30, 40]

# 还可以过滤原来list中的内容并放入新列表
# 比如原有列表a，需要把所有a中的偶数生成新的列表
a = [x for x in range(1,35)]#生成1-34的列表
b = [m for m in a if m%2==0]
print(b)

[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34]

# 列表生成可以嵌套
# 由两个列表a,b
a = [i for i in range(1,10)]
print(a)
b = [i for i in range(100,400) if i % 100 ==0]
print(b)

# 嵌套 == 两个for循环的简写
c = [m*n for m in a for n in b]
print(c)

# 也就是循环嵌套
for m in a:
    for n in b:
        print(m*n,end=" ")
print()

# 嵌套里也可以用条件表达式
c = [m*n for m in a for n in b if m*n > 800]
print(c)

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[100, 200, 300]
[100, 200, 300, 200, 400, 600, 300, 600, 900, 400, 800, 1200, 500, 1000, 1500, 600, 1200, 1800, 700, 1400, 2100, 800, 1600, 2400, 900, 1800, 2700]
100 200 300 200 400 600 300 600 900 400 800 1200 500 1000 1500 600 1200 1800 700 1400 2100 800 1600 2400 900 1800 2700 
[900, 1200, 1000, 1500, 1200, 1800, 1400, 2100, 1600, 2400, 900, 1800, 2700]

关于列表的常用函数

# len：求列表长度
a = [i for i in range(1,10)]
print(len(a))

# max
print(max(a))

9
9

# list 可以将其他格式的数据转化成list
print(list(range(12,16)))

[12, 13, 14, 15]

# 对于简单的数值，采用传值操作，即在函数内对参数d额操作不影响外面的变量
# 对于复杂变量，采用传地址操作，此时函数内的参数h而和外部变量是同一份内容
def a(n):
    n[2] = 300
    print(n)
    return None

def b(n):
    n += 100
    print(n)
    return None

an = [1,2,3,4,5,6]
bn = 9

print(an)
a(an) # an代替n这个变量
print(an)

print(bn)
b(bn)
print(bn)

[1, 2, 3, 4, 5, 6]
[1, 2, 300, 4, 5, 6]
[1, 2, 300, 4, 5, 6]
9
109
9

关于列表的函数

# append 插入一个内容,在末尾追加
a = [i for i in range(1,5)]
print(a)
a.append(100)
print(a)
# insert ：指定位置插入——insert（index，data)
print(a)
a.insert(2,88)
print(a)
# 删除
"""
del删除
pop:拿出一个元素，把最后一个元素拿出来
remove:在列表中删除指定的值的元素
clear:清空
"""
last_ele = a.pop()
print(last_ele)
print(a)
print(id(a))
a.remove(88) #remove是在原list直接操作
print(a)
print(id(a))
a.clear()
print(a)

[1, 2, 3, 4]
[1, 2, 3, 4, 100]
[1, 2, 3, 4, 100]
[1, 2, 88, 3, 4, 100]
100
[1, 2, 88, 3, 4]
2790485789320
[1, 2, 3, 4]
2790485789320
[]

# reverse:翻转列表内容，原地翻转
a = [1,2,3,4,5]
print(a)
a.reverse()
print(a)

[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]

# ectend:扩展列表，两个列表，把一个直接拼到后一个上
a = [1,2,3,4,5]
b = [6,7,8]
a.extend(b)
print(a)

[1, 2, 3, 4, 5, 6, 7, 8]

# count:c查找列表中指定值或元素的个数
print(a)
a_len = a.count(4)
print(a_len)

[1, 2, 3, 4, 5, 6, 7, 8]
1

# copy ：拷贝，浅拷贝
# 列表类型变量赋值
a = [1,2,3,4,5]
print(a)
# list类型，简单赋值操作是传地址操作，也就是指的是同一块内容
b = a
b[3]=5
print(a)
print(b)

# list赋值需要进行copy操作，解决上述问题
b = a.copy()
print(a)
print(b)
b[3]=88
print(a)
print(b)

[1, 2, 3, 4, 5]
[1, 2, 3, 5, 5]
[1, 2, 3, 5, 5]
[1, 2, 3, 5, 5]
[1, 2, 3, 5, 5]
[1, 2, 3, 5, 5]
[1, 2, 3, 88, 5]

# copy 深拷贝
# 深拷贝和浅拷贝的区别
# 深拷贝需要使用特定工具
a = [1,2,3,4]
a2 = [1,3,4,[5,6,7]]
b = a2.copy()#只拷贝了一层，也就是后一个list没有拷贝，只是指向了地址
print(id(a2))
print(id(b))

2790485819080
2790485788296



---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-31-6199c10a3f7b> in <module>()
      6 print(id(a2))
      7 print(id(b))
----> 8 a[3][2] = 55
      9 print(a)


TypeError: 'int' object does not support item assignment

元组—tuple

• 元组可以看成是一个不可更改的list

元组创建

# 创建空元组
t = ()
print(type(t))

# 创建一个只有一个值的元组
t = (1,)
print(type(t))
print(t)

t = 1, #去掉括号也可以
print(type(t))

l = [1,2,3,4,5]
l = tuple(l)
print(type(l))

<class 'tuple'>
<class 'tuple'>
(1,)
<class 'tuple'>
<class 'tuple'>

元组的特性

• 是序列表，有序
• 元组数据值可以访问，不能修改
• 元组数据可以是任意类型
• 总之，list所有特性，除了可修改外，元组都具有
• 索引，分片，序列相加，相乘，成员资格操作等，一模一样

#  索引操作
t = (1,2,3,4,5)
print(t[3])

4

# 超标
print(t[7])

---------------------------------------------------------------------------

IndexError                                Traceback (most recent call last)

<ipython-input-39-450ecc2df4ec> in <module>()
      1 # 超标
----> 2 print(t[7])


IndexError: tuple index out of range

t1 = t[1::2]
print(id(t))
print(id(t1))
print(t)
print(t1)

2790484080160
2790483545288
(1, 2, 3, 4, 5)
(2, 4)

# 序列相加
t1 = (1,2,3)
t2 = (5,6,7)
t1 = t1 +t2
print(t1)
# tuple的不可修改指的是内容不可改
t1[2]=10

(1, 2, 3, 5, 6, 7)



---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-46-341b5a6334c3> in <module>()
      5 print(t1)
      6 # tuple的不可修改指的是内容不可改
----> 7 t1[2]=10


TypeError: 'tuple' object does not support item assignment

# 元组相乘
# 成员检测
# 元组遍历，一般用for
# 1。单层遍历
t = (1,2,3,"xingsu")
for i in t:
    print(i,end=" ")

1 2 3 xingsu 

# 2.双层元组的遍历
t = ((1,2,3),("xingsu","yisi","hh"))
for i in t:
    print(i)
    
for k,v,m in t:
    print(k,"-",v,"-",m)

(1, 2, 3)
('xingsu', 'yisi', 'hh')
1 - 2 - 3
xingsu - yisi - hh

# len:获取元组的长度
t = (1,2,3,4,5)
len(t)

5

# max,min
max(t)
min(t)

1

# tuple:转化或创建元组
l = [1,2,3,4]
t = tuple(l)
print(t)

(1, 2, 3, 4)

元组的函数

• 基本跟list通用

print(t.count(1))

1

# count:计数
# index：指定元素的索引位置，如果有多个，则返回第一个

元组变量交换法

• 两个变量交换值

# 两个变量交换值
a = 1
b = 2
a,b = b,a
print(b)

1

集合-set

• 集合是高中数学中的一个概念
• 一堆确定的无序的唯一的数据，集合每一个数据成为一个元素

# 集合
s = set()
print(type(s))
print(s)

<class 'set'>
set()

# 如果只是用大括号定义，则定义的是一个dict类型
d = {}
print(type(d))

<class 'dict'>

集合的特征

• 集合内部数据无序，即无法索引与分片
• 集合内部数据元素具有唯一性，可以用来排除重复数据
• 集合内的数据，str,int,float,tuple,冰冻集合，内部只能放置可哈希数据

集合的操作

# 成员检测
# in，not in

s = {1,2,3,4}
if "xingsu" in s:
    print(" ")

# 遍历

集合的内涵

# 普通集合内涵
s = {122,343,5656,77,87,7878,21,122,343}
print(s)
ss = {i for i in s} 
print(ss)

{7878, 77, 21, 87, 5656, 122, 343}
{7878, 77, 21, 87, 5656, 122, 343}

# 待条件的额集合内涵
sss = {i for i in s if i % 2 == 0 }
print(sss)

{5656, 122, 7878}

# 多循环
s = {1,12,3,4,5,5}
s1 = {"w","wdd","eeee"}
s2 = {m*n for m in s for n in s1}
print(s2)

{'eeeeeeeeeeee', 'eeeeeeeeeeeeeeeeeeee', 'www', 'w', 'eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', 'wwwwwwwwwwww', 'eeeeeeeeeeeeeeee', 'wddwddwddwddwddwddwddwddwddwddwddwdd', 'wwwww', 'wdd', 'eeee', 'wddwddwddwddwdd', 'wwww', 'wddwddwddwdd', 'wddwddwdd'}

集合函数

• len,max,min:基本一致

# 生成一个集合
l = [1,2,2,2,23,34,5,5,6]
s = set(l)
print(s)

{1, 2, 34, 5, 6, 23}

# add:向集合内添加元素
s = {1}
s.add(22)
print(s)

{1, 22}

# clear 
s = {1,2,3,4,5}
s.clear()
print(s)

set()

# copy
# remove：移除集合中没有的值会报错，而discard不会
# discard:移除集合中指定的值
# pop:随机移除

# 集合函数
# intersection：交集
# difference：差集
# union：并集
# issubset：检查一个集合是否为另一个子集
# issuperset：检查一个集合是否为另一个超集
s1 = {1,2,3,4,5,5}
s2 = {455,6565,76,5645,1,2,3}

s_1 = s1.intersection(s2)
print(s_1)

{1, 2, 3}

frozen set

• 不能进行修改

# 创建
s = frozenset()
print(type(s))

<class 'frozenset'>

dict

• 字典是一种无序的组合数据

# 创建
d = {}
print(type(d))

d = dict()
print(d)

#每一对键值对用逗号隔开
d = {"one":1,"two":2}
print(d)

# 用dict创建由内容字典 one=1

#
d = dict([("one",1),("teo",2)])
print(d)

<class 'dict'>
{}
{'one': 1, 'two': 2}
{'one': 1, 'teo': 2}

字典的特征

• 没有分片和索引
• 数据由键值对组成，即kv对
  • key:必须是可哈希值，比如int，string.float,tuple,但是list和set不行
  • value：任何值

字典常见操作

# 访问数据
d = {"one":1,"two":2}
print(d["one"])# 中括号是键值

d["one"] = "eins"

# 删除
del d["one"]
print(d)

1
{'two': 2}

# 成员检测，in not in  
# 成员检测的是key的内容
d = {"one":1,"two":2}
if 2 in d:
    print("hhh")
if "two" in d:
    print("dada")
if ("one",1)in d:
    print("ok")

dada

# 按key来使用for循环
d = {"one":1,"two":2,"three":3}
# 使用for循环，直接按key值访问
for k in d:
    print(k,d[k])
    
# 可以改成
for k in d.keys():
    print(k,d[k])
    
# 只访字典的值
for v in d.values():
    print(v)
    
# 
for k,v in d.items():
    print(k," ",v)

one 1
two 2
three 3
one 1
two 2
three 3
1
2
3
one   1
two   2
three   3

字典生成式

d = {"one":1,"two":2,"three":3}
# 常规字典生成式
dd = {k:v for k,v in d.items()}
print(dd)

#加限制条件
dd = {k:v for k,v in d.items() if v%2 == 0}
print(dd)

{'one': 1, 'two': 2, 'three': 3}
{'two': 2}

字典相关函数

• 通用函数：len,max,min,dict
• str(字典）：返回字典的字符串格式

d = {}
print(str(d))

{}

# clear：清空
# items：返回字典的键值对组成的元组格式，让你进行迭代
d = {"one":1,"two":2,"three":3}
i = d.items()
print(type(i))
print(i)

<class 'dict_items'>
dict_items([('one', 1), ('two', 2), ('three', 3)])

# keys:返回字典的键组成的一个结构
k = d.keys()
print(type(k))

# values:
v = d.values()
print(type(v))

<class 'dict_keys'>
<class 'dict_values'>

# get：根据指定键返回相应的值，好处式可以设置默认值
d = {"one":1,"two":2}
print(d.get("two"))
# get 默认值是None，可以sh遏制
print(d.get("too",5))

2
5

# fromkeys:使用指定的序列作为键，使用一个值作为字典的所有的键的值
c = dict.fromkeys(d,"sadasd")
print(c)

{'one': 'sadasd', 'two': 'sadasd'}

class PythonStudent():
    #None
    name = None
    age = 18
    course = "Python"
    # 函数的缩进层级
    def doHomework(self):
        print("do homework")
    # 在函数末尾使用return语句
        return None
# 实例化
yiyi = PythonStudent()
print(yiyi.name)
print(yiyi.age)
yiyi.doHomework()

None
18
do homework

class Student():
    name = "yii"
    age = 18
    def say(self):
        self.name = "yiyi"
        self.age = 19
        print("my name is {0}".format(self.name))
        print("my age is{0}".format(self.age))
yueyue = Student()
yueyue.say()

my name is yiyi
my age is19

class Teacher():
    name = "yiyi"
    age = 18
    def say(self):
        self.name = "youyou"
        self.age = 19
        print("my name is {0}".format(self.name))
        print("my age is {0}".format(__class__.age))
    def sayagain():
        print(__class__.name)
        print(__class__.age)
t = Teacher()
t.say()
Teacher.sayagain()

my name is youyou
my age is 18
yiyi
18

# 关于self的案例
class A():
    name = "xingsu"
    age = 18

    def __init__(self):
        self.name = "yoyo"
        self.age = 20

    def say(self):
        print (self.name)
        print (self.age)
class B():
    name = "hhhh"
    age = 22

a = A()
# 此时，系统会默认把a作为第一个参数传入函数
a.say ()
# 此时，self被a替换
A.say(a)
#也可以把A作为参数传入
A.say(A)
# 传入类实例B,因为B具有name和age属性，所以不会报错
A.say(B)
# 以上代码，利用了鸭子模型

yoyo
20
yoyo
20
xingsu
18
hhhh
22

class Person():
    name = "yiyi"
    __age = 19
#print(Person.__age)
print(Person.__dict__)

{'__module__': '__main__', 'name': 'yiyi', '_Person__age': 19, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

# 继承的语法
# 在python中，任何类都有一个共同的父类叫object
class Person():
    name = "xingsu"
    age = 18
    def sleep(self):
        print("sleep")
# 父类写在括号里
class Teacher(Person):
    pass
teacher = Teacher()
print(teacher.name)
print(Teacher.name)

xingsu
xingsu

class Person():
    name = "xingsu"
    age = 18
    __score = 0 # 考试成绩是密码
    _petname = "yisi" # 小名是受保护的
    def sleep(self):
        print("sleep")
# 父类写在括号里
class Teacher(Person):
    def make_test(self):
        pass
teacher = Teacher()
print(teacher.name)
print(Teacher.name)
print(teacher._petname)
#访问私有变量
print(teacher.__score)

xingsu
xingsu
yisi



---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-3-2fb7bdd9cb22> in <module>()
     15 print(teacher._petname)
     16 #访问私有变量
---> 17 print(teacher.__score)


AttributeError: 'Teacher' object has no attribute '__score'

class Person():
    name = "xingsu"
    age = 18
    __score = 0 # 考试成绩是密码
    _petname = "yisi" # 小名是受保护的
    def sleep(self):
        print("sleep")
# 父类写在括号里
class Teacher(Person):
    teacher_id = "8765"
    name = "taolang"
    def make_test(self):
        pass
teacher = Teacher()
print(teacher.name)
print(Teacher.name)
# 子类父类定义同一个名称变量，则优先使用子类本身（谁近用谁）

taolang
taolang



---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-5-c83fb344ec59> in <module>()
     16 print(Teacher.name)
     17 #访问私有变量
---> 18 print(teacher.__score)
     19 # 子类父类定义同一个名称变量，则优先使用子类本身（谁近用谁）


AttributeError: 'Teacher' object has no attribute '__score'

# 子类扩充父类功能
class Person():
    name = "xingsu"
    age = 18
    __score = 0 # 考试成绩是密码
    _petname = "yisi" # 小名是受保护的
    def sleep(self):
        print("sleep")
    def work(self):
        print("i am working")
# 父类写在括号里
class Teacher(Person):
    teacher_id = "8765"
    name = "taolang"
    def make_test(self):
        print("attention")
    def work(self):
        # 第一种 Person.work(self)  #扩充父类功能只需要调用父类相应的函数
        # 第二种
        super().work()
        self.make_test()
xingsu = Teacher()
xingsu.work()

i am working
attention

# 构造函数的概念
class Dog():
    #__init__就是构造函数
    # 每次实例化的时候，第一个被自动调用
    def __init__(self):
        print("i like cat")
kaka = Dog()

i like cat

# 继承中的构造函数
class Animal():
    pass
class sizhi(Animal):
    pass
class Dog(sizhi):
    def __init__(self):
        print("i like cat")
kaka = Dog()

i like cat

# 继承中的构造函数
class Animal():
    def __init__(self):
        print("i am your papa")
class sizhi(Animal):
    print("i am a animal")
class Dog(sizhi):
    def __init__(self):
        print("i like cat")
kaka = Dog()
#
class Cat(sizhi):
    pass
dada = Cat()

i am a animal
i like cat
i am your papa

class A():
    pass
class B(A):
    pass
print(A.__mro__)
print(B.__mro__)

(<class '__main__.A'>, <class 'object'>)
(<class '__main__.B'>, <class '__main__.A'>, <class 'object'>)

# 单继承与多继承
# 子类可以直接拥有父类的属性和方法，私有属性和方法除外
class Fish():
    def __init__(self,name):
        self.name = name
    def swim(self):
        print("i can swim")
class Bird():
    def __init__(self,name):
        slef.name = name

    def fly(self):
        print("i can fly in the sky")
class Person():
    def __init__(self,name):
        self.name = name
    def work(self):
        print("i have to work")
class Superman(Person,Bird,Fish):
    def __init__(self,name):
        self.name = name
a = Superman("xingsu")
a.fly()
a.swim()

i can fly in the sky
i can swim

# Mixin
class Person():
    name = "taolang"
    age = 18

    def eat(self):
        print("i am eating")
    def drink(self):
        print("i am drinking")
    def sleep(self):
        print("i am sleeping")
class Teacher():
    def work(self):
        print("i am working")
class Student():
    def study(self):
        print("i am studying")
class Tutor(Teacher,Student):
    pass
t = Tutor
print(Tutor.__mro__)
print(t.__dict__)
print(Tutor.__dict__)

(<class '__main__.Tutor'>, <class '__main__.Teacher'>, <class '__main__.Student'>, <class 'object'>)
{'__module__': '__main__', '__doc__': None}
{'__module__': '__main__', '__doc__': None}

class TeacherMixin():
    def work(self):
        print("work")
class StudentMixin():
    def study(self):
        print("study")
class TutorMxin(Person,TeacherMixin,StudentMixin):
    pass
tt = Tutor
print(Tutor.__mro__)
print(tt.__dict__)
print(Tutor.__dict__)

(<class '__main__.Tutor'>, <class '__main__.Teacher'>, <class '__main__.Student'>, <class 'object'>)
{'__module__': '__main__', '__doc__': None}
{'__module__': '__main__', '__doc__': None}

# issubclass
class A():
    pass
class B(A):
    pass
print(issubclass(B,A))

True

# isinstance
class A():
    pass
a = A()
print(isinstance(a,A))
print(isinstance(A,A))

True
False

class Student():
    def __init__(self,name,age):
        self.name = name
        self.age = age
        # 如果不想修改dai吗
        self.setName(name)
    # 介绍下自己
    def intro(self):
        print("hi,my name is {0}".format(self.name))
    def setName(self,name):
        self.name = name.upper()   
s1 = Student("taolang",19)
s2 = Student("lining",28)  
s1.intro()
s2.intro()

hi,my name is TAOLANG
hi,my name is LINING

# property
# 需求：姓名大写保存，年龄整数
# x = property(fget,fset,fdel,doc)
class Person():
    # 函数名称任意
    def fget(self):
        return self._name * 2
    # 对属性赋值
    def fset(self,name):
        # 把输入的姓名以大写方式保存
        self._name = name.upper()
    def fdel(self):
        self._name = "noname"
    name = property(fget, fset, fdel, "hhhh")
p1 = Person()
p1.name = "taolang"
print(p1.name)

TAOLANGTAOLANG

# 类的内置
print(Person.__dict__)
print(Person.__doc__)

{'__module__': '__main__', 'fget': <function Person.fget at 0x0000023CD3D36400>, 'fset': <function Person.fset at 0x0000023CD3D366A8>, 'fdel': <function Person.fdel at 0x0000023CD3D36B70>, 'name': <property object at 0x0000023CD3D30A98>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
None

# 魔法函数
# init
class A():
    def __init__(self,name = 0):
        print("hhhhh")
a = A()

hhhhh

# call
class A():
    def __init__(self,name = 0):
        print("hhhhh")
    def __call__(self):
        print("dadada")
a = A()
a()

hhhhh
dadada

# __getattr__
class A():
    name = "taolang"
    age = 18
    def __getattr__(self,name):
        print("aha")
a = A()
print(a.name)
print(a.addr)

taolang
aha
None

# __setattr__案例
class Person():
    def __init__(self):
        pass
    # 对name这个属性进行设置
    def __setattr__(self, name, value):
        print("设置属性：{0}".format(name))
        # 下面语句会导致问题：死循环
        # self.name = value
        # 为避免死循环，规定统一调用父类
        super().__setattr__(name,value)
p = Person()
print(p.__dict__)
p.age = 18

{}
设置属性：age

# __gt__
class Student():
    def __init__(self,name):
        self._name = name
    def __gt__(self, other):
        print("hhh,{0}会比{1}大吗?".format(self,other))
        return self._name > other._name
s1 = Student("one")
s2 = Student("two")
print(s1 > s2)

hhh,<__main__.Student object at 0x000002CE226E6780>会比<__main__.Student object at 0x000002CE226E6748>大吗?
False

# 变量的三种用法
class A():
    def __init__(self):
        self.name = "taolang"
        self.age = 18
a = A()
# 属性的三种方法
# 1.赋值
# 2.读取
# 3.删除
a.name = "桃浪"
print(a.name)
del a.name
print(a.name)

桃浪



---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-1-7b0533c0cee8> in <module>()
     12 print(a.name)
     13 del a.name
---> 14 print(a.name)


AttributeError: 'A' object has no attribute 'name'

# 类属性 property
# 应用场景：对变量除了普通的三种操作，还想增加一些附加的操作，那么可以通过property完成
class A():
    def __init__(self):
        self.name = "taolang"
        self.age = 18
    # 此功能是对类变量进行读取操作时应该执行的函数功能
    def fget(self):
        print("我被读取了") # 每次读取变量就可以打印这句话
        return self.name
    # 模拟的时对变量进行写操作执行的功能
    def fset(self,name):
        print("我被写入了")
        self.name = "hhh" + name # 无论name是什么，对它进行前置“hhh"
    # fdel模拟的时删除变量的时候进行的操作
    def fdel(self):
        pass
    # property的四个参数顺序是固定的
    # 第一个参数代表读取的时候需要调用的函数
    # 第二个参数代表写入的时候需要调用的函数
    # 第三个是删除
    # 上面是变量的操作，下面就要定义变量
    name2 = property(fget, fset,fdel,"这是一个property的例子")
a = A() # 定义类实例
print(a.name)
print(a.name2)

taolang
我被读取了
taolang

# 抽象
class A():
    def say(self):
        pass    # 父类不实现具体的类容
class Dog(A):
    def say(self):
        print("hhh") # 在子类中实现
d = Dog()
d.say()

hhh

# 抽象
class A():
    def say(self):
        pass    # 父类不实现具体的类容
class Dog(A):
    def say(self):
        print("hhh") # 在子类中实现
d = Dog()
d.say()

# 抽象类的实现
import abc
# 声明一个类并且指定当前类的元类
class Human(metaclass=abc.ABCMeta):
    # 定义一个抽象方法
    @abc.abstractmethod
    def smoking(self):
        pass # 只要是抽象，这里全用pass代替
    # 定义类抽象方法
    @abc.abstractclassmethod
    def drink(self):
        pass
    # 定义静态抽象方法
    @abc.abstractstaticmethod
    def play():
        pass

hhh

# 函数名可以当变量使用
def sayhello(name):
    print("{0},nihao".format(name))
sayhello("taolang")
tao = sayhello # 把函数名赋值给了 tao
tao("桃浪")

taolang,nihao
桃浪,nihao

# 自己组装一个类
class A():
    pass
    def say(self):
        print("hhhhh")
class B():
    def say(self):
        print("enheng")
say(8) # 8当成参数传进去，调用函数
A.say= say # 函数名称可以当变量用
a = A()
a.say()

b = B()
b.say()

hhhhh
hhhhh
enheng

# 组装2 绑定实例
from types import MethodType
class A():
    pass

def say(self):
    print("hhhhh")
    
a = A()
a.say = MethodType(say,A) # 把当成方法类say赋值给实例say
a.say()

hhhhh

# 组装3 使用type
def say(self):
    print("saying")
def talk(self):
    print(talking)
# 用type来实例化一个类
A = type("hhh",(object, ),{"class_say":say,"class_talk":talk})
# name = hhh ;bases是的父类-object，——tuple的写法;字典：键值对，函数：功能
# 然后可以像正常访问一样使用类
a = A()
dir(a)

['__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__',
 'class_say',
 'class_talk']

# 元类
# 元类写法是固定的，必须继承自type
# 元类命名一般以MetaClass结尾
class taolangMetaClass(type):
    # 注意以下写法
    def __new__(cls, name, bases, attrs):
        # 自己的业务处理
        print("hhhh,woshishui")
        attrs["id"] = "ddddd"
        return type.__new__(cls, name, bases, attrs) # 返回是调用父类
# 元类定义完就可以使用
class yiyi(object,metaclass=taolangMetaClass):
    pass
t = yiyi()
t.id

hhhh,woshishui





'ddddd'