字符串

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

转义字符

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

# 可以使用嵌套引号，即外层使用双引号
# 转义字符
#  == 
# \ == 
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    zipheshiwendangn    '

变量的作用域

• 变量由作用范围限制
• 分类
  • 全局（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 = 100ndef fun():n    print(a1)n    a2=99n    print(a2)nprint(a1)', 'a1 = 100ndef fun():n    print(a1)n    a2=99n    print(a2)nprint(a1)nfun()', 'a1 = 100ndef fun():n    print(a1)n    a2=99 # 作用范围是funn    print(a2)nprint(a1)nfun()nprint(a2)', 'a1 = 100ndef fun():n    print(a1)n    a2=99 # 作用范围是funn    print(a2)nprint(a1)nfun()nprint(a2) #超出范围。所以不能调用', 'ndef fun():n    b1 = 100n    print(b1)n    b2=99 # 作用范围是funn    print(a2)nprint(b1)nfun()nprint(b2) #超出范围。所以不能调用', 'ndef fun():n    global b1 = 100n    print(b1)n    b2=99 # 作用范围是funn    print(a2)nprint(b1)nfun()nprint(b2) #超出范围。所以不能调用', 'ndef fun():n    global b1 n    b1= 100n    print(b1)n    b2=99 # 作用范围是funn    print(a2)nprint(b1)nfun()nprint(b2) #超出范围。所以不能调用', 'ndef fun():n    global b1 n    b1= b1.globaln    print(b1)n    b2=99 # 作用范围是funn    print(a2)nprint(b1)nfun()nprint(b2) #超出范围。所以不能调用', 'ndef fun():n    global b1 n    b1= b1(global)n    print(b1)n    b2=99 # 作用范围是funn    print(a2)nprint(b1)nfun()nprint(b2) #超出范围。所以不能调用', 'a = 1', 'a = 1nb = 2nndef fun(c,d):n    e = 111n    print("locals={}".format(locals()))', 'a = 1nndef fun(c,d):n    e = 111n    print("locals={0}".format(locals()))n    print("globals={0}".format(globals()))n    nfun(100,200)'], '_oh': {}, '_dh': ['C:\Users\12633'], 'In': ['', 'a1 = 100ndef fun():n    print(a1)n    a2=99n    print(a2)nprint(a1)', 'a1 = 100ndef fun():n    print(a1)n    a2=99n    print(a2)nprint(a1)nfun()', 'a1 = 100ndef fun():n    print(a1)n    a2=99 # 作用范围是funn    print(a2)nprint(a1)nfun()nprint(a2)', 'a1 = 100ndef fun():n    print(a1)n    a2=99 # 作用范围是funn    print(a2)nprint(a1)nfun()nprint(a2) #超出范围。所以不能调用', 'ndef fun():n    b1 = 100n    print(b1)n    b2=99 # 作用范围是funn    print(a2)nprint(b1)nfun()nprint(b2) #超出范围。所以不能调用', 'ndef fun():n    global b1 = 100n    print(b1)n    b2=99 # 作用范围是funn    print(a2)nprint(b1)nfun()nprint(b2) #超出范围。所以不能调用', 'ndef fun():n    global b1 n    b1= 100n    print(b1)n    b2=99 # 作用范围是funn    print(a2)nprint(b1)nfun()nprint(b2) #超出范围。所以不能调用', 'ndef fun():n    global b1 n    b1= b1.globaln    print(b1)n    b2=99 # 作用范围是funn    print(a2)nprint(b1)nfun()nprint(b2) #超出范围。所以不能调用', 'ndef fun():n    global b1 n    b1= b1(global)n    print(b1)n    b2=99 # 作用范围是funn    print(a2)nprint(b1)nfun()nprint(b2) #超出范围。所以不能调用', 'a = 1', 'a = 1nb = 2nndef fun(c,d):n    e = 111n    print("locals={}".format(locals()))', 'a = 1nndef fun(c,d):n    e = 111n    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 = 1nb = 2nndef fun(c,d):n    e = 111n    print("locals={}".format(locals()))', '_ii': 'a = 1', '_iii': 'ndef fun():n    global b1 n    b1= b1(global)n    print(b1)n    b2=99 # 作用范围是funn    print(a2)nprint(b1)nfun()nprint(b2) #超出范围。所以不能调用', '_i1': 'a1 = 100ndef fun():n    print(a1)n    a2=99n    print(a2)nprint(a1)', 'a1': 100, 'fun': <function fun at 0x00000179D36C1A60>, '_i2': 'a1 = 100ndef fun():n    print(a1)n    a2=99n    print(a2)nprint(a1)nfun()', '_i3': 'a1 = 100ndef fun():n    print(a1)n    a2=99 # 作用范围是funn    print(a2)nprint(a1)nfun()nprint(a2)', '_i4': 'a1 = 100ndef fun():n    print(a1)n    a2=99 # 作用范围是funn    print(a2)nprint(a1)nfun()nprint(a2) #超出范围。所以不能调用', '_i5': 'ndef fun():n    b1 = 100n    print(b1)n    b2=99 # 作用范围是funn    print(a2)nprint(b1)nfun()nprint(b2) #超出范围。所以不能调用', '_i6': 'ndef fun():n    global b1 = 100n    print(b1)n    b2=99 # 作用范围是funn    print(a2)nprint(b1)nfun()nprint(b2) #超出范围。所以不能调用', '_i7': 'ndef fun():n    global b1 n    b1= 100n    print(b1)n    b2=99 # 作用范围是funn    print(a2)nprint(b1)nfun()nprint(b2) #超出范围。所以不能调用', '_i8': 'ndef fun():n    global b1 n    b1= b1.globaln    print(b1)n    b2=99 # 作用范围是funn    print(a2)nprint(b1)nfun()nprint(b2) #超出范围。所以不能调用', '_i9': 'ndef fun():n    global b1 n    b1= b1(global)n    print(b1)n    b2=99 # 作用范围是funn    print(a2)nprint(b1)nfun()nprint(b2) #超出范围。所以不能调用', '_i10': 'a = 1', 'a': 1, '_i11': 'a = 1nb = 2nndef fun(c,d):n    e = 111n    print("locals={}".format(locals()))', 'b': 2, '_i12': 'a = 1nndef fun(c,d):n    e = 111n    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'

最后

以上就是粗暴画笔为你收集整理的python基础语法第一弹字符串表达式运算符逻辑运算符程序结构23 分支 for循环三大结构分支循环语句24 while 函数while循环函数函数文档变量的作用域glboals,locals函数eval（）函数exec()函数递归函数内置数据结构（变量类型)list列表相加列表的遍历列表内涵：list content关于列表的常用函数关于列表的函数元组—tuple元组的函数元组变量交换法集合-set集合的特征集合的操作集合的内涵集合函数dict字典的特征字典常见操作字典生成式字典相关函数的全部内容，希望文章能够帮你解决python基础语法第一弹字符串表达式运算符逻辑运算符程序结构23 分支 for循环三大结构分支循环语句24 while 函数while循环函数函数文档变量的作用域glboals,locals函数eval（）函数exec()函数递归函数内置数据结构（变量类型)list列表相加列表的遍历列表内涵：list content关于列表的常用函数关于列表的函数元组—tuple元组的函数元组变量交换法集合-set集合的特征集合的操作集合的内涵集合函数dict字典的特征字典常见操作字典生成式字典相关函数所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。