一、初识Python

1.Python介绍

  • Python是解释型语言

  • Python(英国发音:/ˈpaɪθən/ 美国发音:/ˈpaɪθɑːn/),是一种广泛使用的高级编程语言,属于通用型编程语言,由吉多·范罗苏姆创造,第一版发布于1991年。可以视之为一种改良(加入一些其他编程语言的优点,如面向对象)的LISP。作为一种解释型语言,Python的设计哲学强调代码的可读性和简洁的语法(尤其是使用空格缩进划分代码块,而非使用大括号或者关键词)。相比于C++或Java,Python让开发者能够用更少的代码表达想法。不管是小型还是大型程序,该语言都试图让程序的结构清晰明了。

2.Python的用途

  • WEB应用
  • 爬虫程序
  • 科学计算
  • 自动化运营
  • 云计算
  • 人工智能

二、基本语法

1.一些注意点

  1. 在Python中严格区分大小写

  2. Python中的每一行就是一条语句,每条语句以换行结束

  3. Python中每一行语句不要过长(规范中建议每行不要超过80个字符)

  4. 一条语句可以分多行编写,多行编写时语句后边以\结尾

    如:

    print('he\
    ll\
    o')
    
    
  5. Python是缩进严格的语言,所以在Python中不要随便写缩进

  6. 在Python中使用#来表示注释,#后的内容都属于注释,注释的内容将会被解释器所忽略

2.变量与标识符

2.1 变量

变量(variable)变量可以用来保存字面量,并且变量中保存的字面量是不定的,变量本身没有任何意思,它会根据不同的字面量表示不同的意思

2.2 标识符

标识符 在Python中所有可以自主命名的内容都属于标识符,比如:变量名、函数名、类名

标识符必须遵循标识符的规范

  1. 标识符中可以含有字母、数字、但是不能使用数字开头
    例子:a_1 _a1 1a

  2. 标识符不能是Python中的关键字和保留字,也不建议使用Python中的函数名作为标识符,因为这样会导致函数被覆盖

  3. 命名规范:
    在Python中注意遵循两种命名规范:

  • 下划线命名法
    所有字母小写,单词之间使用_分割
    max_length min_length hello_world xxx_yyy_zzz

  • 帕斯卡命名法(大驼峰命名法)
    首字母大写,每个单词开头字母大写,其余字母小写
    MaxLength MinLength HelloWorld XxxYyyZzz

    注:如果使用不符合标准的标识符,将会报错 SyntaxError: invalid syntax

2.3数据类型

不可变数据: Number(数字)、String([字符串]、Tuple(元组)

可变数据: List(列表)、Dictionary(字典)、Set(集合)

python数据类型

3.数值类型

  1. 在Python中所有的整数都是int类型

  2. Python中的整数的大小没有限制,可以是一个无限大的整数

    如:

     c = 999999999999999999999999999999999999999999999
    
  3. 如果数字的长度过大,可以使用下划线作为分隔符

如:

c = 123_456_789
  1. 在Python中所有的小数都是float类型,对浮点数进行运算时,可能会得到一个不精确的结果

    如:

    c = 0.1 + 0.2 # 0.30000000000000004
    

4.字符串

4.1初识字符串

  1. 字符串必须使用引号引起来,不使用不是字符串,引号可以是双引号,也可以是单引号,但是注意不要混着用

  2. 相同的引号之间不能嵌套

    如:

    # s = "子曰:"学而时习之,乐呵乐呵!""这样写不对
    s = '子曰:"学而时习之,乐呵乐呵!"'
    
  3. 单引号和双引号不能跨行使用,三重引号可以换行,并且会保留字符串中的格式

    如:

    s = '锄禾日当午,\
    汗滴禾下土,\
    谁知盘中餐,\
    粒粒皆辛苦'
    s = '''锄禾日当午,
    汗滴禾下土,
    谁知盘中餐,
    粒粒皆辛苦'''
    

4.2格式化字符串

  1. 字符串之间也可以进行加法运算,如果将两个字符串进行相加,则会自动将两个字符串拼接为一个,但是字符串不能和其他的类型进行加法运算,如果做了会出现异常

  2. 如果需要与数值类型进行拼接可以使用下面的几种方法

    • 使用逗号进行拼接

      a=1
      print('a =',a)
      
    • 使用占位符

      a=123.1844
      print("a= %0.2f"%a)
      
    • 格式化字符串

      a=100
      print(f"a={a}")
      
  3. 在创建字符串时,可以在字符串中指定占位符

    • %s 在字符串中表示任意字符

    • %f 浮点数占位符

    • %d 整数占位符

    如:

    b = 'Hello %s'%'孙悟空'
    b = 'hello %s 你好 %s'%('tom','孙悟空')
    b = 'hello %3.5s'%'abcdefg' # %3.5s字符串的长度限制在3-5之间
    b = 'hello %s'%123.456
    b = 'hello %.2f'%123.456
    b = 'hello %d'%123.95
    
  4. 格式化字符串,可以通过在字符串前添加一个f来创建一个格式化字符串,在格式化字符串中可以直接嵌入变量

    如:

    a=1
    b=2
    c = f'hello {a} {b}'
    

4.3复制字符串

字符串的复制(将字符串和数字相乘)

如:

a = a * 5#aaaaa
#如果将字符串和数字相乘,则解释器会将字符串重复指定的次数并返回

5.布尔类型与空值

  1. 布尔值主要用来做逻辑判断,布尔值一共有两个 True 和 False,布尔值实际上也属于整型,True就相当于1,False就相当于0

  2. None(空值)

6.类型检查与类型转换

6.1类型检查

type()用来检查值的类型,该函数会将检查的结果作为返回值返回,可以通过变量来接收函数的返回值

如:

print(type(1)) # <class 'int'>
print(type(1.5)) # <class 'float'>
print(type(True)) # <class 'bool'>
print(type('hello'))  # <class 'str'>
print(type(None)) # <class 'NoneType'>

6.2类型转换

类型转换四个函数 int() float() str() bool()

7.运算符

7.1算术运算符

  • //表示整除
  • **表示乘方
  • / 除法运算符,运算时结果总会返回一个浮点类型

7.2逻辑运算符

  1. 注意写法
  • not 逻辑非

  • and 逻辑与 Python中的与运算是短路的与,如果第一个值为False,则不再看第二个值

    如:

    True and print('你猜我出来吗?') 第一个值是True,会看第二个值,所以print()会执行
    False and print('你猜我出来吗?')第一个值是False,不会看第二个值,所以print()不会执行
    

    注:在python中 result = 1 < 2 < 3 # 相当于 1 < 2 and 2 < 3

  • or 逻辑或

    如:

    False or print('你猜我出来吗?') 第一个值为False,继续看第二个,所以打印语句执行
    True or print('你猜我出来吗?') 第一个值为True,不看第二个,所以打印语句不执行
    
  1. 非布尔值的与或运算

    当我们对非布尔值进行与或运算时,Python会将其当做布尔值运算,最终会返回原值

    • 与运算的规则

      • 与运算是找False的,如果第一个值是False,则不看第二个值
      • 如果第一个值是False,则直接返回第一个值,否则返回第二个值

    如:

    # True and True
    result = 1 and 2 # 2
    # True and False
    result = 1 and 0 # 0
    # False and True
    result = 0 and 1 # 0
    # False and False
    result = 0 and None # 0
    
    • 或运算的规则

      • 或运算是找True的,如果第一个值是True,则不看第二个值
    • 如果第一个值是True,则直接返回第一个值,否则返回第二个值

    如:

    # True or True
    result = 1 or 2 # 1
    # True or False
    result = 1 or 0 # 1
    # False or True
    result = 0 or 1 # 1
    # False or False
    result = 0 or None # None
    

7.3条件运算符

条件运算符(三元运算符)

  • 语法: 语句1 if 条件表达式 else 语句2

  • 执行流程:
    条件运算符在执行时,会先对条件表达式进行求值判断
    如果判断结果为True,则执行语句1,并返回执行结果
    如果判断结果为False,则执行语句2,并返回执行结果

    如:

    a = 30
    b = 50
    # print('a的值比较大!') if a > b else print('b的值比较大!')
    # 获取a和b之间的较大值
    max = (a if a > b else b)
    

7.4关系运算符

  1. is 比较两个对象是否是同一个对象,比较的是对象的id
  2. is not 比较两个对象是否不是同一个对象,比较的是对象的id

三、流程控制语句

1.条件判断语句

  • 语法:if 条件表达式 :
    代码块

  • 默认情况下,if语句只会控制紧随其后的那条语句,如果希望if可以控制多条语句,则可以在if后跟着一个代码块

  • 代码块

    • 代码块中保存着一组代码,同一个代码块中的代码,要么都执行要么都不执行
    • 代码块就是一种为代码分组的机制
    • 如果要编写代码块,语句就不能紧随在后边,而是要写在下一行
    • 代码块以缩进开始,直到代码恢复到之前的缩进级别时结束

    示例:

    if False :
        print(123)
        print(456)
        print(789)
        print(101112)
        
    if 10 < num < 20 :
        print('num比10大,num比20小!')
    

2.输入、输出函数

  • input()函数
    该函数用来获取用户的输入input()调用后,程序会立即暂停,等待用户输入
    用户输入完内容以后,点击回车程序才会继续向下执行
    用户输入完成以后,其所输入的的内容会以返回值得形式返回
    input()函数中可以设置一个字符串作为参数,这个字符串将会作为提示文字显示

    示例:

    # 获取用户输入的用户名
    username = input('请输入你的用户名:')
    # 判断用户名是否是admin
    if username == 'admin' :
        print('欢迎管理员光临!')
    

    注意:input()的返回值是一个字符串

  • print()函数

    该函数用于向控制台输出

3.if-elif-else语句

3.1 if-else语句

  • 语法:
    if 条件表达式 :
    代码块
    else :
    代码块
  • 执行流程:
    if-else语句在执行时,先对if后的条件表达式进行求值判断
    如果为True,则执行if后的代码块
    如果为False,则执行else后的代码块
  • 示例:
age = 7
if age > 17 :
    print('你已经成年了~~')
else :
    print('你还未成年~~')

3.2 if-elif-else语句

  • 语法:
    if 条件表达式 :
    代码块
    elif 条件表达式 :
    代码块
    elif 条件表达式 :
    代码块
    elif 条件表达式 :
    代码块
    else :
    代码块
  • 示例:
age = 210

if age > 200 :
    print('活着可真没劲呢!')
elif age > 100 :
    print('你也是老大不小了!')
elif age >= 60 :
    print('你已经退休了!')
elif age >= 30 :
    print('你已经是中年了!')
elif age >= 18 :
    print('你已经成年了!')
else :
    print('你还是个小孩!')

4.循环语句

  • while循环

    • 语法:
      while 条件表达式 :
      代码块
      else :
      代码块
    • 执行流程:
      while语句在执行时,会先对while后的条件表达式进行求值判断,
      如果判断结果为True,则执行循环体(代码块),
      循环体执行完毕,继续对条件表达式进行求值判断,以此类推,
      直到判断结果为False,则循环终止,如果循环有对应的else,则执行else后的代码块
    • 示例:
    i = 0
    while i < 10 :
        i += 1
        print(i,'hello')
    else :
        print('else中的代码块')
    
  • for循环

    语法:
    for 变量 in 序列 :
    代码块

  • 嵌套循环

    示例:

    i = 0
    while i < 5:
        # 创建一个内层循环来控制图形的宽度
        j = 0
        while j < 5:
            print("* ",end='')
            j += 1
        print()
        i += 1
    
  • break可以用来立即退出循环语句(包括else)

    continue可以用来跳过当次循环

    break和continue都是只对离他最近的循环起作用

    pass是用来在判断或循环语句中占位的

    示例:

    i = 0
    while i < 5:
        if i == 3:
            break
        print(i)
        i += 1
    else :
        print('循环结束')
    
    i = 0
    while i < 5:
        i += 1
        if i == 2:
            continue
        print(i)
    else :
        print('循环结束')
        
    i = 0
    if i < 5:
        pass
    

四、序列

1.列表

  1. 创建列表

    my_list = [] # 创建了一个空列表
    
    • 一个列表中可以存储多个元素,也可以在创建列表时,来指定列表中的元素,当向列表中添加多个元素时,多个元素之间使用,隔开
    my_list = [10,20,30,40,50] # 创建了一个保护有5个元素的列表
    
    • 列表中可以保存任意的对象

      my_list = [10,'hello',True,None,[1,2,3],print]
      
    • 列表中的对象都会按照插入的顺序存储到列表中,我们可以通过索引(index)来获取列表中的元素

      # 语法:my_list[索引] my_list[0]
      print(my_list[4])
      # 如果使用的索引超过了最大的范围,会抛出异常
      # print(my_list[5]) IndexError: list index out of range
      
  2. 获取列表的长度

    len()函数,通过该函数可以获取列表的长度

    示例:

    my_list = [10,20,30,40,50]
    print(len(my_list))
    

2.切片

切片:指从现有列表中,获取一个子列表

  1. 列表的索引可以是负数

如果索引是负数,则从后向前获取元素,-1表示倒数第一个,-2表示倒数第二个 以此类推

  1. 通过切片来获取指定的元素

    • 语法:列表[起始:结束]

      • 通过切片获取元素时,会包括起始位置的元素,不会包括结束位置的元素
      • 做切片操作时,总会返回一个新的列表,不会影响原来的列表
      • 起始和结束位置的索引都可以省略不写
      • 如果省略结束位置,则会一直截取到最后
      • 如果省略起始位置,则会从第一个元素开始截取
      • 如果起始位置和结束位置全部省略,则相当于创建了一个列表的副本

      示例:

      print(stus[1:])
      print(stus[:3])
      print(stus[:])
      
    • 语法:列表[起始:结束:步长]

      • 步长表示,每次获取元素的间隔,默认值是1

      • 步长不能是0,但是可以是负数

      • 如果是负数,则会从列表的后部向前边取元素

        示例:

         print(stus[0:5:3])
         print(stus[::-1])
        

3.序列的一些通用操作

  1. +可以将两个列表拼接为一个列表

    my_list = [1,2,3] + [4,5,6]#[1, 2, 3, 4, 5, 6]
    
  2. *可以将列表重复指定的次数

    my_list = [1,2,3] * 5#[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
    
  3. in 和 not in

  • in用来检查指定元素是否存在于列表中
    如果存在,返回True,否则返回False

  • not in用来检查指定元素是否不在列表中
    如果不在,返回True,否则返回False

    示例:

    stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精','沙和尚','沙和尚']
    print('牛魔王' not in stus)
    print('牛魔王' in stus)
    
  1. min() 获取列表中的最小值

  2. max() 获取列表中的最大值

    示例:

    arr = [10,1,2,5,100,77]
    print(min(arr) , max(arr))
    
  3. 两个方法(method),方法和函数基本上是一样,只不过方法必须通过 对象.方法() 的形式调用

    • s.index() 获取指定元素在列表中的第一次出现时索引

      print(stus.index('沙和尚'))
      
    • s.count() 统计指定元素在列表中出现的次数

    print(stus.count('牛魔王'))
    

4.修改序列元素

  1. 直接通过索引来修改元素

    stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']
    stus[0] = 'sunwukong'
    stus[2] = '哈哈'
    
  2. 通过del来删除元素

    del stus[2] # 删除索引为2的元素
    
  3. 通过切片来修改列表

    #在给切片进行赋值时,只能使用序列
    stus[0:2] = ['牛魔王','红孩儿'] #使用新的元素替换旧元素
    stus[0:2] = ['牛魔王','红孩儿','二郎神']#使用切片插入元素时,插入元素的个数不一定等于切片的长度
    stus[0:0] = ['牛魔王'] # 向索引为0的位置插入元素
    #当设置了步长时,序列中元素的个数必须和切片中元素的个数一致
    stus[::2] = ['牛魔王','红孩儿','二郎神']
    
  4. 通过切片来删除元素

    del stus[0:2]
    del stus[::2]
    stus[1:3] = []
    

    注: 以上操作,只适用于可变序列,但对于不可变序列,可以通过 list() 函数将其他的序列转换为list

5.列表的方法

  1. append() 向列表的最后添加一个元素

    stus = ['孙悟空','猪八戒','沙和尚','唐僧']
    stus.append('唐僧')#['孙悟空', '猪八戒', '沙和尚', '唐僧', '唐僧']
    
  2. insert() 向列表的指定位置插入一个元素

    • 参数:
      1.要插入的位置
      2.要插入的元素

    • 示例:

      stus.insert(2,'唐僧')
      
  3. extend() 向列表尾部追加一个序列,将列表中的每个元素都追加进来,在原有列表上增加

stus = ['孙悟空','猪八戒','沙和尚','唐僧']
stus.extend(['唐僧','白骨精'])
#stus.extend('str')#追加一个字符串或者元组也可以
  1. +与extend()在效果上具有相同的功能,但是实际上生成了一个新的列表来存放这两个列表的和

    A = [1, 2, 3]
    B = [4, 5, 6]
    print(A+B)#[1, 2, 3, 4, 5, 6]
    print(A)#[1, 2, 3]
    
  2. clear() 清空序列

    stus.clear()
    
  3. pop() 根据索引删除并返回被删除的元素

    result = stus.pop(2) # 删除索引为2的元素
    # result = stus.pop() # 删除最后一个
    print('result =',result)
    
  4. remove() 删除指定值的元素,如果相同值得元素有多个,只会删除第一个

    stus.remove('猪八戒')
    
  5. reverse() 用来反转列表

    stus.reverse()
    
  6. sort() 用来对列表中的元素进行排序,默认是升序排列

    如果需要降序排列,则需要传递一个reverse=True作为参数

    my_list = [10,1,20,3,4,5,0,-2]
    print('修改前',my_list)
    my_list.sort(reverse=True)
    print('修改后',my_list)
    

6.遍历列表

  1. while循环

    stus = ['孙悟空','猪八戒','沙和尚','唐僧','白骨精','蜘蛛精']
    i = 0
    while i < len(stus):
        print(stus[i])
        i += 1
    
  2. for循环

    • 语法:
      for 变量 in 序列 :
      代码块

    • 示例:

      for s in stus :
          print(s)
      

7.range

  • **range() **是一个函数,可以用来生成一个自然数的序列

  • 该函数需要三个参数

    • 起始位置(可以省略,默认是0)

    • 结束位置

    • 步长(可以省略,默认是1)

  • 示例:

    r = range(5) # 生成一个这样的序列[0,1,2,3,4]
    r = range(0,10,2)
    r = range(10,0,-1)
    
  • 应用

    • 通过range()可以创建一个执行指定次数的for循环

    • 示例:

      for i in range(30):
          print(i)
      

8.元组

  1. 元组 tuple 一个不可变的序列 它的操作的方式基本上和列表是一致的

  2. 创建元组

    • 使用()来创建元组

      my_tuple = () # 创建了一个空元组
      print(my_tuple,type(my_tuple)) # <class 'tuple'>
      my_tuple = (1,2,3,4,5) # 创建了一个5个元素的元组
      
    • 元组是不可变对象,不能尝试为元组中的元素重新赋值

      my_tuple[3] = 10 #TypeError: 'tuple' object does not support item assignment
      
    • 当元组不是空元组时,括号可以省略 如果元组不是空元组,它里边至少要有一个,

      my_tuple = 10,20,30,40
      my_tuple = 40,
      
    • 元组中可以保存任意的对象

      t=(1,"ddda",[1,"dd",'a'])
      print(t,type(t))#(1, 'ddda', [1, 'dd', 'a']) <class 'tuple'>
      
  3. 元组的解包(解构)

    • 解包指就是将元组当中每一个元素都赋值给一个变量

      my_tuple = 10 , 20 , 30 , 40
      a,b,c,d = my_tuple
      
      print("a =",a)
      print("b =",b)
      print("c =",c)
      print("d =",d)
      
    • 交互a 和 b的值,这时我们就可以利用元组的解包

      a = 100
      b = 300
      a , b = b , a
      
    • 在对一个元组进行解包时,变量的数量不一定必须和元组中的元素的数量一致,也可以在变量前边添加一个*,这样变量将会获取元组中所有剩余的元素

      a , b , *c = my_tuple
      a , *b , c = my_tuple
      *a , b , c = my_tuple
      a , b , *c = [1,2,3,4,5,6,7]
      a , b , *c = 'hello world'
      

      注:不能同时出现两个或以上的*变量 否则会报错

五、字典

1.字典简介

  • 字典属于一种新的数据结构,称为映射(mapping)
  • 字典的作用和列表类似,都是用来存储对象的容器
  • 列表存储数据的性能很好,但是查询数据的性能的很差, 在查询元素时,字典的效率是非常快的

2.创建字典

  1. 使用 {} 来创建字典

    d = {} # 创建了一个空字典
    
    • 语法:

    • 字典的值可以是任意对象

    • 字典的键可以是任意的不可变对象(int、str、bool、tuple …),但是一般我们都会使用str

    • 字典的键是不能重复的,如果出现重复的后边的会替换到前边的

    • 示例:

      d = {'name':'孙悟空' , 'age':18 , 'gender':'男' , 'name':'sunwukong'}
      
    • 可以根据键来获取值

      print(d['name'],d['age'],d['gender'])
      

      注:如果使用了字典中不存在的键,会报错

  2. 使用 dict()函数来创建字典

    • 每一个参数都是一个键值对,参数名就是键,参数名就是值(这种方式创建的字典,key都是字符串)

    • 示例:

      d = dict(name='孙悟空',age=18,gender='男') 
      
  3. 也可以将一个包含有双值子序列的序列转换为字典

    • 双值序列,序列中只有两个值,[1,2] (‘a’,3) ‘ab’

    • 子序列,如果序列中的元素也是序列,那么我们就称这个元素为子序列

    • 示例:

      d = dict([('name','孙悟饭'),('age',18)])
      

3.字典的使用

  1. len() 获取字典中键值对的个数

    print(len(d))
    
  2. in 检查字典中是否包含指定的键

    not in 检查字典中是否不包含指定的键

    print('hello' in d)
    
  3. 获取字典中的值,根据键来获取值

    • 语法:d[key]

      print(d['age'])
      
    • 通过[]来获取值时,如果键不存在,会抛出异常 KeyError

  4. get(key, default) 该方法用来根据键来获取字典中的值,如果值不在字典中返回默认值。

    • 如果获取的键在字典中不存在,会返回None

    • 也可以指定一个默认值,来作为第二个参数,这样获取不到值时将会返回默认值

    • 示例:

      print(d.get('name'))
      print(d.get('hello','默认值'))
      
  5. setdefault(key, default) 可以用来向字典中添加key-value

    • 如果key已经存在于字典中,则返回key的值,不会对字典做任何操作

    • 如果key不存在,则向字典中添加这个key,并设置value

    • 示例:

      result = d.setdefault('name','猪八戒')
      result = d.setdefault('hello','猪八戒')
      
  6. update([other])

    • 将其他的字典中的key-value添加到当前字典中

    • 如果有重复的key,则后边的会替换到当前的

    • 示例:

      d = {'a':1,'b':2,'c':3}
      d2 = {'d':4,'e':5,'f':6, 'a':7}
      d.update(d2)
      
  7. 删除,可以使用 del 来删除字典中的 key-value

    del d['a']
    del d['b']
    
  8. popitem() 随机删除字典中的一个键值对,一般都会删除最后一个键值对

  • 删除之后,它会将删除的key-value作为返回值返回

  • 返回的是一个元组,元组中有两个元素,第一个元素是删除的key,第二个是删除的value

  • 当使用popitem()删除一个空字典时,会抛出异常 KeyError: ‘popitem(): dictionary is empty’

  • 示例:

    d.popitem()
    result = d.popitem()
    
  1. pop(key, default) 根据key删除字典中的key-value
  • 会将被删除的value返回

  • 如果删除不存在的key,会抛出异常

  • 如果指定了默认值,再删除不存在的key时,不会报错,而是直接返回默认值

  • 示例:

    result = d.pop('d')
    result = d.pop('z','这是默认值')
    
  1. clear() 用来清空字典

    d.clear()
    
  2. copy() 该方法用于对字典进行浅复制

    • 复制以后的对象,和原对象是独立,修改一个不会影响另一个

    • 注意,浅复制会简单复制对象内部的值,如果值也是一个可变对象,这个可变对象不会被复制

    • 示例:

      d = {'a':1,'b':2,'c':3}
      d2 = d.copy()
      # d['a'] = 100
      
      d = {'a':{'name':'孙悟空','age':18},'b':2,'c':3}
      d2 = d.copy()
      d2['a']['name'] = '猪八戒'
      
      
      print('d = ',d , id(d))
      print('d2 = ',d2 , id(d2))
      

4.遍历字典

  1. keys() 该方法会返回字典的所有的key

    • 该方法会返回一个序列,序列中保存有字典的所有的键

    • 示例:

      d = {'name':'孙悟空','age':18,'gender':'男'}
      
      # 通过遍历keys()来获取所有的键
      for k in d.keys() :
          print(k , d[k])
      
  2. values()

    • 该方法会返回一个序列,序列中保存有字典的左右的值

    • 示例:

      for v in d.values():
          print(v)
      
  3. items()

    • 该方法会返回字典中所有的项

    • 它会返回一个序列,序列中包含有双值子序列,双值分别是,字典中的key和value

    • 示例:

      for k,v in d.items() :
          print(k , '=' , v)
      

六、集合

1.集合简介

  1. 集合(set)是一个无序的不重复元素序列。集合和列表非常相似
  2. 集合和列表的不同点:
    • 集合中只能存储不可变对象
    • 集合中存储的对象是无序(不是按照元素的插入顺序保存)
    • 集合中不能也不会出现重复的元素

2.创建集合

  1. 使用 {} 来创建集合

    s = {10,3,5,1,2,1,2,3,1,1,1,1}
    print(s) # {1, 2, 3, 5, 10}
    print(type(s)) # <class 'set'>
    

    注:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典

  2. 使用 set() 函数来创建集合

    • 创建空集合

      s = set() 
      print(s) # set()
      print(type(s)) # <class 'set'>
      
    • 通过set()来将序列和字典转换为集合

      s = set([1,2,3,4,5,1,1,2,3,4,5])
      s = set('hello')
      s = set({'a':1,'b':2,'c':3}) # 使用set()将字典转换为集合时,只会包含字典中的键
      

3.集合的方法

  1. len() 来获取集合中元素的数量

    print(len(s))
    
  2. 使用in和not in来检查集合中的元素

    print('c' in s)
    
  3. add() 向集合中添加元素

    s.add(10)
    s.add(30)
    
  4. update() 将一个集合中的元素添加到当前集合中

    • update()可以传递序列或字典作为参数,字典只会使用键

    • 示例:

      s2 = set('hello')
      s.update(s2)
      s.update((10,20,30,40,50))
      s.update({10:'ab',20:'bc',100:'cd',1000:'ef'})
      
  5. pop() 随机删除并返回一个集合中的元素

    result = s.pop()
    
  6. remove() 删除集合中的指定元素

    s.remove(100)
    s.remove(1000)
    
  7. clear() 清空集合

    s.clear()
    
  8. copy() 对集合进行浅复制

    s1=s.copy()
    print(s1 , type(s1))
    

七、函数

1.函数简介

  1. 函数也是一个对象
  2. 函数可以用来保存一些可执行的代码,并且可以在需要时,对这些语句进行多次的调用

2.创建函数

  1. 语法:

    def 函数名([形参1,形参2,…形参n]) :
    代码块

  2. 函数名必须要符号标识符的规范(可以包含字母、数字、下划线、但是不能以数字开头)

  3. 函数中保存的代码不会立即执行,需要调用函数代码才会执行

  4. 调用函数:
    函数对象()

  5. 示例:

    def fn() :
        print('这是我的第一个函数!')
        print('hello')
        print('今天天气真不错!')
        
    print(fn) #<function fn at 0x03D2B618>
    print(type(fn)) #<class 'function'>
    

3.函数的参数

  1. 在定义函数时,可以在函数名后的()中定义数量不等的形参,多个形参之间使用,隔开

  2. 定义形参时,可以为形参指定默认值,指定了默认值以后,如果用户传递了参数则默认值没有任何作用,如果用户没有传递,则默认值就会生效

  3. 示例:

    def mul(a,b,c):
        print(a*b*c)
    
    def fn(a = 5 , b = 10 , c = 20):
        print('a =',a)
        print('b =',b)
        print('c =',c)
    
    # fn(1 , 2 , 3)
    # fn(1 , 2)
    # fn()
    
  4. 实参的传递方式

    • 位置参数:将对应位置的实参复制给对应位置的形参

      # 第一个实参赋值给第一个形参,第二个实参赋值给第二个形参... 
       fn(1 , 2 , 3)
      
    • 关键字参数:可以不按照形参定义的顺序去传递,而直接根据参数名去传递参数

      fn(b=1 , c=2 , a=3)
      print('hello' , end='')
      

      注:位置参数和关键字参数可以混合使用,混合使用关键字和位置参数时,必须将位置参数写到前面

  5. 不定长的参数

    • 在定义函数时,可以在形参前边加上一个*****,这样这个形参将会获取到所有的实参, 它将会将所有的实参保存到一个元组中

      def fn(*a):
          print("a =",a,type(a))
      
      fn(1,2,3,4,5)#a = (1, 2, 3, 4, 5) <class 'tuple'>
      
    • 带星号的参数,可以和其他参数配合使用,但带星号的形参只能有一个

      def fn2(a,b,*c):
          print('a =',a)
          print('b =',b)
          print('c =',c)
      # 第一个参数给a,第二个参数给b,剩下的都保存到c的元组中
      
    • 可变参数不是必须写在最后,但是注意,带*的参数后的所有参数,必须以关键字参数的形式传递

      def fn2(a,*b,c):
          print('a =',a)
          print('b =',b)
          print('c =',c)
      fn2(1,5,'d',6,c="f")
      
    • *形参只能接收位置参数,而不能接收关键字参数

    • **形参可以接收其他的关键字参数,它会将这些参数统一保存到一个字典中

      • 字典的key就是参数的名字,字典的value就是参数的值
      • **形参只能有一个,并且必须写在所有参数的最后
      def fn3(b,c,**a) :
          print('a =',a,type(a))
          print('b =',b)
          print('c =',c)
      
      fn3(1,2,h=3,e=10,f=20)
      #a = {'h': 3, 'e': 10, 'f': 20} <class 'dict'>
      #b = 1
      #c = 2
      
    • 传递实参时,也可以在序列类型的参数前添加星号,这样他会自动将序列中的元素依次作为参数传递

      • 这里要求序列中元素的个数必须和形参的个数的一致

        def fn4(a,b,c):
            print('a =',a)
            print('b =',b)
            print('c =',c)
        t = (10,20,30)
        fn4(*t)  
        d = {'a':100,'b':200,'c':300}
        fn4(**d)
        

4.函数返回值

  1. 返回值,返回值就是函数执行以后返回的结果

  2. 可以通过 return 来指定函数的返回值,return 后边可以跟任意的对象,返回值甚至可以是一个函数

  3. 如果仅仅写一个return 或者 不写return,则相当于return None ,在函数中,return后的代码都不会执行,return 一旦执行函数自动结束

  4. 示例:

    def fn():
        # return 'Hello'
        # return [1,2,3]
        # return {'k':'v'}
        def fn2() :
            print('hello')
        return fn2 # 返回值也可以是一个函数
    

5.文档字符串

  • 文档字符串(doc str)

    • 在定义函数时,可以在函数内部编写文档字符串,文档字符串就是函数的说明

    • 当我们编写了文档字符串时,就可以通过help()函数来查看函数的说明

    • 文档字符串非常简单,其实直接在函数的第一行写一个字符串就是文档字符串

      def fn(a:int,b:bool,c:str='hello') -> int:
          '''
          这是一个文档字符串的示例
      
          函数的作用:。。。。。
          函数的参数:
              a,作用,类型,默认值。。。。
              b,作用,类型,默认值。。。。
              c,作用,类型,默认值。。。。
          '''
          return 10
      
      help(fn)
      
  • help() 是Python中的内置函数

  • 通过help()函数可以查询python中的函数的用法

  • 语法:help(函数对象)

6.作用域

  1. 作用域(scope)指的是变量生效的区域

  2. 在Python中一共有两种作用域

    • 全局作用域
      • 全局作用域在程序执行时创建,在程序执行结束时销毁
      • 所有函数以外的区域都是全局作用域
      • 在全局作用域中定义的变量,都属于全局变量,全局变量可以在程序的任意位置被访问
    • 函数作用域
      • 函数作用域在函数调用时创建,在调用结束时销毁
      • 函数每调用一次就会产生一个新的函数作用域
      • 在函数作用域中定义的变量,都是局部变量,它只能在函数内部被访问
  3. 变量的查找

    当我们使用变量时,会优先在当前作用域中寻找该变量,如果有则使用,如果没有则继续去上一级作用域中寻找,如果有则使用,如果依然没有则继续去上一级作用域中寻找,以此类推。直到找到全局作用域,依然没有找到,则会抛出异常

  4. 命名空间

    • 命名空间指的是变量存储的位置,每一个变量都需要存储到指定的命名空间当中

    • 每一个作用域都会有一个它对应的命名空间

    • 全局命名空间,用来保存全局变量。函数命名空间用来保存函数中的变量

    • 命名空间实际上就是一个字典,是一个专门用来存储变量的字典

    • locals()用来获取当前作用域的命名空间,如果在全局作用域中调用locals()则获取全局命名空间,如果在函数作用域中调用locals()则获取函数命名空间

      scope = locals() # 当前命名空间
      print(type(scope))
      
    • globals() 函数可以用来在任意位置获取全局命名空间

7.高阶函数

  1. 高阶函数:接收函数作为参数,或者将函数作为返回值的函数是高阶函数

  2. 当我们使用一个函数作为参数时,实际上是将指定的代码传递进了目标函数

    def fn(func , lst) :
        '''
            fn()函数可以将指定列表中的所有偶数获取出来,并保存到一个新列表中返回
    
            参数:
                lst:要进行筛选的列表
        '''
        # 创建一个新列表
        new_list = []
        
        # 对列表进行筛选
        for n in lst :
            # 判断n的奇偶
            if func(n) :
                new_list.append(n)
            # if n > 5 :
            #     new_list.append(n)
    
        # 返回新列表
        return new_list
    def fn4(i):
        return i % 3 == 0
            
    print(fn(fn4 , l))
    
  3. 匿名函数 lambda 函数表达式

    • lambda函数表达式专门用来创建一些简单的函数,他是函数创建的又一种方式

    • 语法:lambda 参数列表 : 返回值

    • 匿名函数一般都是作为参数使用,其他地方一般不会使用

      def fn5(a , b):
          return a + b
      
      # (lambda a,b : a + b)(10,20)
      # 也可以将匿名函数赋值给一个变量,一般不会这么做
      fn6 = lambda a,b : a + b
      # print(fn6(10,30))
      
  4. sort() 该方法用来对列表中的元素进行排序

  • sort()方法默认是直接比较列表中的元素的大小

  • 在sort()可以接收一个关键字参数 , key

  • key需要一个函数作为参数,当设置了函数作为参数,每次都会以列表中的一个元素作为参数来调用函数,并且使用函数的返回值来比较元素的大小

    l = ['bb','aaaa','c','ddddddddd','fff']
    l.sort(key=len)
    
  1. sorted()

    • 这个函数和sort()的用法基本一致,但是sorted()可以对任意的序列进行排序

    • 并且使用sorted()排序不会影响原来的对象,而是返回一个新对象

      l = [2,5,'1',3,'6','4']
      
      print('排序前:',l)#排序前: [2, 5, '1', 3, '6', '4']
      print(sorted(l,key=int))#['1', 2, 3, '4', 5, '6']
      print('排序后:',l)#排序后: [2, 5, '1', 3, '6', '4']
      

八、对象

1.什么是对象

  • 对象是内存中专门用来存储数据的一块区域。
  • 对象中可以存放各种数据(比如:数字、布尔值、代码)
  • 对象由三部分组成:
    • 对象的标识(id)
    • 对象的类型(type)
    • 对象的值(value)

2.类的简介

  1. ,简单理解它就相当于一个图纸。在程序中我们需要根据类来创建对象
  2. 类也是一个对象,类就是一个用来创建对象的对象
  3. 类是type类型的对象,定义类实际上就是定义了一个type类型的对象
  4. 在类的代码块中,我们可以定义变量和函数
    • 变量会成为该类实例的公共属性,所有的该类实例都可以通过 对象.属性名 的形式访问
    • 函数会成为该类实例的公共方法,所有该类实例都可以通过 对象.方法名() 的形式调用方法

3.类的创建

  1. 使用class关键字来定义类,语法和函数很像

  2. 语法:

    class 类名([父类]):
    代码块

    class 类名([父类]) :
    
            公共的属性... 
    
            # 对象的初始化方法
            def __init__(self,...):
                ...
    
            # 其他的方法    
            def method_1(self,...):
                ...
    
            def method_2(self,...):
                ...
                
    class MyClass():
        pass
    mc = MyClass() # mc就是通过MyClass创建的对象,mc是MyClass的实例
    
    
  3. isinstance() 用来检查一个对象是否是一个类的实例

    result = isinstance(mc_2,MyClass)
    result = isinstance(mc_2,str)
    
  4. 可以向对象中添加变量,对象中的变量称为属性

    • 语法:对象.属性名 = 属性值

      mc.name = '孙悟空'
      mc_2.name = '猪八戒'
      
  5. 在类的代码块中,我们可以定义变量和函数

    • 类中我们所定义的变量,将会成为所有的实例的公共属性

    • 所有实例都可以访问这些变量

    • 在类中也可以定义函数,类中的定义的函数,我们称为方法

      class Person :
          name = 'swk' # 公共属性,所有实例都可以
          
          def say_hello(self) :
              print('你好!我是 %s' %self.name)
      

4.对象的初始化

  1. 特殊方法

    • 在类中可以定义一些特殊方法(魔术方法),特殊方法都是以__开头,__结尾的方法
    • 特殊方法不需要我们自己调用,不要尝试去调用特殊方法,特殊方法将会在特殊的时刻自动调用
    • 学习特殊方法:
      • 特殊方法什么时候调用
      • 特殊方法有什么作用
  2. 创建对象的流程(p1 = Person()的运行流程)

    • 创建一个变量
    • 在内存中创建一个新对象
    • __init__(self)方法执行
    • 将对象的id赋值给变量
  3. __init__(self) 方法

    • init可以用来向新创建的对象中初始化属性

      class Person :
          def __init__(self,name):
              # print(self)
              # 通过self向新建的对象中初始化属性
              self.name = name
      
          def say_hello(self):
              print('大家好,我是%s'%self.name)
      

5.封装

  1. 什么是封装?

    • 封装是面向对象的三大特性之一
    • 封装指的是隐藏对象中一些不希望被外部所访问到的属性或方法
  2. 如何隐藏一个对象中的属性?

    • 将对象的属性名,修改为一个外部不知道的名字
  3. 如何获取(修改)对象中的属性?

    • 需要提供一个getter和setter方法使外部可以访问到属性
      • getter 获取对象中的指定属性(get_属性名)
      • setter 用来设置对象的指定属性(set_属性名)
  4. 示例1:

    class Dog:
        '''
            表示狗的类
        '''
        def __init__(self , name , age):
            self.hidden_name = name
            self.hidden_age = age
    
        def say_hello(self):
            print('大家好,我是 %s'%self.hidden_name) 
    
        def get_name(self):
            '''
                get_name()用来获取对象的name属性
            '''    
            # print('用户读取了属性')
            return self.hidden_name
    
        def set_name(self , name):
            # print('用户修改了属性')
            self.hidden_name = name
    
        def get_age(self):
            return self.hidden_age
    
        def set_age(self , age):
            if age > 0 :
                self.hidden_age = age    
    
  5. 可以为对象的属性使用双下划线开头,__xxx

    • 双下划线开头的属性,是对象的隐藏属性,隐藏属性只能在类的内部访问,无法通过对象访问

    • 其实隐藏属性只不过是Python自动为属性改了一个名字

    • 实际上是将名字修改为了,_类名__属性名 比如 __name -> _Person__name

    • 示例:

      class Person:
          def __init__(self,name):
              self.__name = name
      
          def get_name(self):
              return self.__name
      
          def set_name(self , name):
              self.__name = name        
      
      p = Person('孙悟空')
      
      print(p.__name) __开头的属性是隐藏属性,无法通过对象访问
      p.__name = '猪八戒'
      print(p._Person__name)
      p._Person__name = '猪八戒'
      
      print(p.get_name())
      
  6. 封装最终版

    class Person:
        def __init__(self,name,age):
            self._name = name
            self._age = age
    
        # property装饰器,用来将一个get方法,转换为对象的属性
        # 添加为property装饰器以后,我们就可以像调用属性一样使用get方法
        # 使用property装饰的方法,必须和属性名是一样的
        @property    
        def name(self):
            print('get方法执行了~~~')
            return self._name
    
        # setter方法的装饰器:@属性名.setter
        @name.setter    
        def name(self , name):
            print('setter方法调用了')
            self._name = name        
    
        @property
        def age(self):
            return self._age
    
        @age.setter    
        def age(self , age):
            self._age = age  
    p = Person('猪八戒',18)
    
    p.name = '孙悟空'
    p.age = 28
    
    print(p.name,p.age)
    

6.继承

  1. 在创建类时,如果省略了父类,则默认父类为object

  2. object是所有类的父类,所有类都继承自object

    class Person(object):
        pass
    
    class Animal:
        def run(self):
            print('动物会跑~~~')
    
        def sleep(self):
            print('动物睡觉~~~')
    class Dog(Animal):
        def bark(self):
            print('汪汪汪~~~') 
    
        def run(self):
            print('狗跑~~~~')  
            
    d = Dog()        
    
  3. issubclass() 检查一个类是否是另一个类的子类

    print(issubclass(Animal , Dog))
    print(issubclass(Animal , object))
    
  4. isinstance() 用来检查一个对象是否是一个类的实例

    • 如果这个类是这个对象的父类,也会返回True

    • 所有的对象都是object的实例

      print(isinstance(print , object))
      
  5. 父类中的所有方法都会被子类继承,包括特殊方法,也可以重写特殊方法

    class Animal:
        def __init__(self,name):
            self._name = name
    
        def run(self):
            print('动物会跑~~~')
    
        def sleep(self):
            print('动物睡觉~~~')
    
        @property
        def name(self):
            return self._name
    
        @name.setter    
        def name(self,name):
            self._name = name
            
    class Dog(Animal):
    
        def __init__(self,name,age):
            # 希望可以直接调用父类的__init__来初始化父类中定义的属性
            # super() 可以用来获取当前类的父类,
            #   并且通过super()返回对象调用父类方法时,不需要传递self
            super().__init__(name)
            self._age = age
    
        def bark(self):
            print('汪汪汪~~~') 
    
        def run(self):
            print('狗跑~~~~')   
    
        @property
        def age(self):
            return self._age
    
        @age.setter    
        def age(self,age):
            self._age = name        
    
    d = Dog('旺财',18) 
    
    print(d.name)       
    print(d.age)              
    
  6. 在Python中是支持多重继承的,也就是我们可以为一个类同时指定多个父类

    • 可以在类名的()后边添加多个类,来实现多重继承

    • 多重继承,会使子类同时拥有多个父类,并且会获取到所有父类中的方法

    • 如果多个父类中有同名的方法,则会现在第一个父类中寻找,然后找第二个,然后找第三个。。。

    • 前边父类的方法会覆盖后边父类的方法

      class A(object):
          def test(self):
              print('AAA')
      
      class B(object):
          def test(self):
              print('B中的test()方法~~')
      
          def test2(self):
              print('BBB')
              
              
      class C(A,B):
          pass        
      
    • 类名.__bases__ 这个属性可以用来获取当前类的所有父类

      print(B.__bases__) #(<class 'object'>,)
      
      print(C.__bases__) # (<class '__main__.A'>, <class '__main__.B'>
      
版权声明:本文为ZhengLord原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://www.cnblogs.com/ZhengLord/p/16897567.html