python部分总结

作者: 胖波波玻璃球 | 来源:发表于2020-07-12 19:56 被阅读0次

    python这部分的学习,我本身是充满信心的,毕竟本身工作当中用到了pandas,但是在学习过程中还是发现了许多不足,例如循环部分while True,高级函数用法等这些细节知识点,现在通过复盘再把这些知识点总结一下,不理解的地方再多思考和练习,最终达到巩固和熟练基础知识的目的。

    一、输出

    1 格式化输出

    常用格式化字符:
    %s-----字符串
    %d-----有符号十进制整数
    %06d-----表示输出的整数显示位数,不足的地方使用0补全
    %-6d------做左对齐
    %f-----浮点数
    %.2f-----表示小数点后只显示两位
    %%-----%

    2 补充和思考

    '-' :指定左对齐。
    '+' :表示数值总要带符号,正数带“+”号,负数带 “-” 号。
    0 :表示不补充空格,而是补充 0。
    示例如下:

    num = 39
    print("num is: %06d" % num)      #  最小宽度为6,左边不足的用 0 补充,输出:num is: 000039
    print("pi is: %010.4f" % pi)      # 最小宽度为10位,小数点后保留4位,右对齐,左边补0,输出:pi is: 00003.1416
    name = 'Michael'
    print("the name is: %.4s" % name)    # 字符串保留4个字符,输出:the name is: Mich
    print("the name is: %8.2s" % name)  # 保留2个字符,最小宽度为8位,输出:the name is:       Mi
    

    二 if条件和逻辑语句

    1 注意知识点1

    当使用if条件语句时,最后一行打印无论是否满足条件都会打印。代码如下:

    age = 18
    if age >= 18:
        print("可以进入网吧嗨皮")
    else:
        print("还没有长大,回家吧")
    # 无论条件是否满足都会执行
    print("这句代码什么时候执行?")
    

    2 注意知识点2

    当定义一个布尔型变量 is_employee,编写代码判断是否是本公司员工的写法如下:

    is_employee = False
    
    if not is_employee: # 等于if is_employee is not True:
    
        print("do not enter")
    

    3 注意知识点3

    elif 和 else 都必须和 if 联合使用,而不能单独使用,
    elif 强调的是 并列的多种结果
    逻辑运算符 强调的是 与某个结果有关的 多个条件

    4 注意知识点4

    if 条件语句中使用多个条件的逻辑运算时要分别用()括起来:

    # 假定电脑就只会出石头
    player = int(input("请出拳 石头(1)/剪刀(2)/布(3):"))
    computer = 1
    
    # player满足赢的条件,注意用括号分别括起来
    if ((player == 1 and computer == 2) or
        (player == 2 and computer == 3) or
        (player == 3 and computer == 1)):
    
        print("you win")
    elif player == computer:
        print("once again")
    else:
        print("you lose")
    

    三 循环语句

    1 while 基本语法规则

    变量设置初始值 # 注意!
    
    while 条件(判断 变量是否满足条件):
        条件满足时,做的事情1
        条件满足时,做的事情2
        条件满足时,做的事情3
        ...(省略)...
    
        修改变量 # 注意!
    

    举例(注意在变量设置初始值和修改变量的用法):

    # 1. 定义重复次数计数器
    i = 1
    
    # 2. 使用 while 判断条件
    while i <= 10000:
        # 要重复执行的代码
        print("媳妇儿,我错了")
        # 处理计数器 i
        i = i + 1
    

    2 break用法

    在循环过程中,如果 某一个条件满足后,不再希望循环继续执行,可以使用 break 退出循环

    i = 0
    while i < 10:
        # break 某一条件满足时,退出循环,不再执行后续重复的代码
        # i == 3
        if i == 3:
            break
        print(i)
        i += 1
    print("over")
    

    3 continue用法

    在循环过程中,如果 某一个条件满足后,不希望执行本次循环代码,但是又不希望退出循环,可以使用 continue。也就是:在整个循环中,只有某些条件,不需要执行循环代码,而其他条件都需要执行

    i = 0
    while i < 10:
        # 当 i == 7 时,不希望执行需要重复执行的代码
        if i == 7:
            # 在使用 continue 之前,同样应该修改计数器
            # 否则会出现死循环
            i += 1
            continue
        # 重复执行的代码
        print(i)
        i += 1
    

    4 循环嵌套用法

    复习例子a

    row = 1
    while row <= 5:
        # 假设 python 没有提供字符串 * 操作
        # 在循环内部,再增加一个循环,实现每一行的 星星 打印
        col = 1
        while col <= row:
            print("*", end="")
            col += 1
        # 每一行星号输出完成后,再增加一个换行
        print("")
        row += 1
    

    复习例子b

    # 定义起始行
    row = 1
    # 最大打印 9 行
    while row <= 9:
        # 定义起始列
        col = 1
        # 最大打印 row 列
        while col <= row:
            # end = "",表示输出结束后,不换行
            # "\t" 可以在控制台输出一个制表符,协助在输出文本时对齐
            print("%d * %d = %d" % (col, row, row * col), end="\t")
            # 列数 + 1
            col += 1
        # 一行打印完成的换行
        print("")
        # 行数 + 1
        row += 1
    

    5 作业中注意点 while True:

    while True:作为无限循环,经常在不知道循环次数的时候使用,并且需要在循环内使用break才会停止。采用该语句的核心思想是:如果出现错误的话,还可以继续循环,例如在用户输入用户名或密码错误的情况下返回到开始部分,请求继续输入。在作业中是猜年龄当尝试3次后,还没猜对,但还想继续玩,while True就可以继续让其猜3次,以此往复。

    age_of_oldboy='65'
    count=0
    while True:
      if count == 3:
          choice=input('继续Y/N?: ')
          if choice == 'Y' or choice == 'y':
              count=0
          else:
              break # 重要!!
      guess=input('请输入年龄: ')
    
      if guess == age_of_oldboy:
          print('你猜对啦')
          break # 重要!!
    
      count+=1
    

    五 列表

    1列表的增删改查

    列表.png

    a.增加元素

    1) 列表.insert(索引,数据): 在指定位置插入一个值

    2) 列表.append(数据):在末尾追加一个值,这个最常用

    3) 列表.extend(Iterable):将另一个列表(也可以)的全部内容追加到末尾

    注意知识点:使用 append 追加的是将后面的列表作为一个整体追加到最后了,而使用 extend 追加的是将里面的元素依次追加到最后

    b. 删除元素:

    1) del 列表[索引]:删除指定索引元素

    2)列表.remove(数据)

    3)列表.pop():可指定索引删除,不指定会删除最后一个

    注意知识点:pop 函数还有返回值,会返回被删除的值

    c. 修改元素:直接指定索引赋值,就是修改元素内容

    d. 查询元素:

    1)* 列表[索引]:根据索引获取(查询)值*

    2) 列表.index(数据):查询给定值的索引,即想要知道元素的位置,如果查询元素有多个相同值只会返回第一个值出现的记录

    3) 列表.count(数据):查询值出现的次数

    4) len(列表):有多少个元素

    5) if 数据 in 列表:判断元素是否在列表中,用作条件语句中

    e. 元素排序:list.sort()

    注意知识点:sort 方法还有一个参数,key,这个参数是传递函数方法名的,可以传入自定义的函数名或者是匿名函数

    list=[5,7,9,0,4,'8']
    # 这里是使用 int 函数,意思是将里面可以转换为数字的字符串转换成数字来排序,如果转换不成功会报错,如‘8d’ 显示是不能转换为数字类型的
    list.sort(key=int,reverse=True)
    print(list)
    

    2 列表的循环遍历

    a while

    while循环实现列表的遍历:打印出列表的所有元素,i 是起到循环得到索引值的作用

    i = 0
    name_list = ["zhangsan", "lisi", "wangwu"]
    list_count = len(name_list)
    while i < list_count:
        name = name_list[i]
        print(name)
        i += 1
    

    b for

    for 循环其实就是专门用来对高级变量进行循环遍历的(如元组、字典)

    for name in name_list:
        循环内部针对列表元素进行操作
        print(name)
    

    3 list 应用场景

    • 列表 一般只存储相同类型的数据
    • 通过 for循环,在循环体内部,针对列表中的每一项元素,执行相同的操作

    六 元组

    注意:元组的元素不能改变,但是,如果元组中的元素如果为列表/字典时,则可以修改列表/字典中的元素的值,数据之间使用,分隔

    1 元组的查询

    查询.png
    tuple=(5,7,3,7)
    
    print(tuple)
    # 根据索引查询值
    print(tuple[0])
    # 根据值查询索引
    print(tuple.index(7))
    # 求值出现的次数
    print(tuple.count(7))
    # 求元组的长度:即元素个数
    print(len(tuple))
    # for 遍历
    for n in tuple:
        print(n)
    

    2 应用场景:自动组包

    自动组包的默认类型:组包后是一个元组,可以用来快速交换两个变量的值

    a=3
    b=4
    # 赋值的右侧有多个数据时,会自动组包成元组
    # 如果赋值的左侧接收的变量和右侧的变量的个数一致,就会自动解包,一一对应赋值
    b,a=a,b
    # 注意:右侧组包后相当于是变成了一个元组
    # b,a=(a,b)
    print(a)
    print(b)
    
    # 如果个数不一致左边就得到一个元组
    c=a,b
    print(c)
    print(type(c))
    

    七 字典

    字典使用键值对(key、value对)存储数据,键值对之间使用,分隔

    • 键 key 索引:注意索引不再是 0,1,2... 了,虽然可以用数字,但是一般使用字符串
    • 值 value 数据
    • key:value 之间使用:分隔
    • 键必须是唯一的:如果有多个,后者会覆盖前者
    • 值 可以取任何数据类型,但键只能字符串、数字或元组
    • 字典是无序对象的集合

    1 字典的增改删查

    字典.png

    a 增加元素

    1) 字典[键] = 数据

    键不存在,会添加键值对;键存在,会修改键值对的值

    b 删除元素

    1) del 字典[键]

    2) 字典.pop(键)

    注意:pop 删除成功了会返回被删除的值

    3) 字典.clear

    c 修改元素

    1) 字典[键] = 数据

    2) 字典.setdefault(键,数据)

    3) 字典.update(字典2)

    d 查询元素

    1)字典[键]:注意不能根据值来查询键

    2)字典.get(键)

    2 字典的遍历

    • 字典.keys()、字典.values()、
    • 字典.items():返回的是一个元组
    • 以上三个都是视图对象类型,可以用for遍历,也可以转换为list
    • 直接对一个字典进行 for 遍历,取出来的是 键

    3 应用

    • 使用 多个键值对,存储 描述一个 物体 的相关信息 —— 描述更复杂的数据信息
    • 将 多个字典 放在 一个列表 中,再进行遍历,在循环体内部针对每一个字典进行 相同的处理

    八 函数

    1 定义

    • 定义函数:在函数中编写代码,实现功能
    • 调用函数:执行编写代码
      定义函数的格式如下:
    def 函数名():
    
        函数封装的代码
        ……
    

    函数的执行顺序总结:

    ​ 程序代码始终都是顺序执行的,也就是从第一行到最后一行,但在程序执行到 def func 定义函数的语句时不会运行函数,而是将函数名作为标识符添加到内存中而不会运行函数里面的代码。而当程序继续往下,到调用函数的语句时,就会到内存中查询是否有该函数,如果有就调用函数名对应的函数代码。这里也有一个要注意的事项,就是函数调用必须在函数定义后,不然找不到函数会报错。

    注意:函数体相对比较独立,函数定义的上方,应该和其他代码(包括注释)保留 两个空行

    2 函数的参数

    a 如何处理只能固定数值相加的函数??

    def sum_2_num():
    
        num1 = 10
        num2 = 20
        result = num1 + num2
    
        print("%d + %d = %d" % (num1, num2, result))
    
    sum_2_num()
    

    解决:

    def sum_2_num(num1, num2):
    
        result = num1 + num2
    
        print("%d + %d = %d" % (num1, num2, result))
    
    sum_2_num(50, 20)
    

    总结:函数的参数增加了函数的通用性,针对相同的数据处理逻辑,能适应更多的数据

    • 函数内部,把把参数当做 变量 使用,进行需要的数据处理
    • 函数调用时,按照函数定义的参数顺序,把 希望在函数内部处理的数据,通过参数 传递

    b 形参和实参

    • 形参:定义 函数时,小括号中的参数,是给真实数据占位用的,在函数内部 作为变量使用
    • 实参:调用 函数时,小括号中的参数,是传递到 函数内部 的 真实数据
    a = 5  
    
    def test1(a): 
        # 这里 a 是形参,是在函数内部定义的,作用域只在函数内部
        a += 1
        print("%d" % a)
    
    test1(2)  
    # 这里因为形参的作用域不到这里,所以这个 a 是外面的 a
    print("%d" % a)
    

    3 函数返回值

    def sum_2_num(num1, num2):
        """对两个数字的求和"""
    
        return num1 + num2
    
    # 调用函数,并使用 result 变量接收计算结果
    result = sum_2_num(10, 20)
    
    print("计算结果是 %d" % result)
    

    a 关于return

    • return 后面可以不跟值
    def func_sum():
        """求和 1+2"""
        sum_num = 1 + 2
        print(sum_num)
        return
    
    • 函数中凡是代码执行到 return 时,都会终止函数的执行,返回到函数调用的代码处。所以可以灵活利用 return 结束程序
    def func_sum():
        """求和 1+2"""
        sum_num = 1 + 2
        print(sum_num)
    
        return
        # 这行代码不会执行了
        print('不会执行这行代码')
    
    res=func_sum()
    print(res)
    

    4 四种函数类型

    1 无参数,无返回值的函数

    此类函数,不能接收参数,也没有返回值,一般情况下,打印提示灯类似的功能,使用这类的函数

    def print_menu():
        print('--------------------------')
        print('      xx涮涮锅 点菜系统')
        print('')
        print('  1.  羊肉涮涮锅')
        print('  2.  牛肉涮涮锅')
        print('  3.  猪肉涮涮锅')
        print('--------------------------')
    

    2 无参数,有返回值的函数

    此类函数,不能接收参数,但是可以返回某个数据,一般情况下,像采集数据,用此类函数

    # 获取温度
    def get_temperature():
        # 这里是获取温度的一些处理过程
        # 为了简单起见,先模拟返回一个数据
        return 24
    
    temperature = get_temperature()
    print('当前的温度为:%d' % temperature)
    

    3 有参数,无返回值的函数

    此类函数,能接收参数,但不可以返回数据,一般情况下,对某些变量设置数据而不需结果时,用此类函数

    4 有参数,有返回值的函数

    # 计算1~num的累积和
    def calculate_num(num):
        result = 0
        i = 1
        while i < =num:
            result = result + i
            i += 1
        return result
    
    result = calculate_num(100)
    print('1~100的累积和为:%d' % result)
    

    5 列表推导式

    • 基本方式:
    • a=[x for x in range(4)]
    • b=[x for x in range(1,7) if x%2!=0]
    • d=[(x,y) for x in range(1,4) for y in range(3,5)]

    6 匿名函数

    a 语法: lambda [参数列表]: 表达式

    b 要点

    lambda 表达式的几个要点:

    • lambda 表达式必须使用 lambda 关键字定义。
    • 在 lambda 关键字之后、冒号左边的是参数列表,可以不给参数,也可以给多个参数。多个参数用逗号分隔,冒号右边是 lambda 表达的返回值。
    • lambda 表达式也叫做匿名函数,也是单行函数体的函数。

    c 应用

    • 对于单行函数,使用 lambda 表达式更简洁,省去定义函数的过程。
    • 对于不需要多次复用的函数,使用 lambda 表达式可以在用完之后立即释放,提高性能。
    # 计算平方
    x = map(lambda x: x * x, range(5))
     print([i for i in x])
    # 计算偶数的平方
    y = map(lambda x: x * x if x % 2 ==0 else 0, range(5))
    print([i for i in y])
    

    注意:Lambda函数能接收任何数量的参数但只能返回一个表达式的值,匿名函数不能直接调用print,因为lambda需要一个表达式

    d 函数作为参数传递

    # 定义一个函数
    def fun(a, b, opt):
         print("a = %s" % a)
         print("b = %s" % b)
         print("result =%s" % opt(a, b))
    
    # 调用函数
    fun(1, 2, lambda x,y:x+y)
    

    e 作为内置函数的参数

    # 作为内置函数的参数
    stus = [
        {"name": "zhangsan", "age": 18},
        {"name": "lisi", "age": 19},
        {"name": "wangwu", "age": 17}
    ]
    # 字典中每个key
    a = map(lambda x: x['name'],stus)
    print([i for i in a])
    # 按name排序
    stus.sort(key=lambda x:x['name'])
    print(stus)
    # 按age排序
    stus.sort(key=lambda x:x['age'])
    print(stus)
    

    九 高级函数

    1 局部变量

    • 局部变量,就是在 函数内部定义的变量
    • 局部变量的作用域只在函数内部

    2 全局变量

    • 在函数外边定义的变量叫做 全局变量
    • 全局变量能够在所有的函数中进行访问
    # 定义全局变量
    a = 100
    
    def test1():
        print(a)
    
    def test2():
        print(a)
    
    # 调用函数
    test1()
    test2()
    
    • 函数内修改全局变量: global 声明
    a = 10
    
    def test():
        global a
        a = 5  # 修改全局变量
        print("函数内a:%d" %a)
    
    test()
    print("函数外a:%d" %a)
    

    3 函数返回值二

    a 多个return

    def is_even_num(num):
        """判断奇偶数"""
        if num % 2 == 0:
            return True
        else:
            return False
    

    b 多个返回值

    def func2():
        return 1,1.5
    
    #返回多个数据时,自动将数据组包成元组
    a = func2()
    print(a)
    
    #用多个变量接收返回值,python会自动将元组 拆包 成单个数据
    a,b = func2()
    print(a)
    print(b)
    
    a,b,c = 1,1.5,"hello"
    print(a)
    print(b)
    print(c)
    

    当返回多个数据时,python会自动将数据 组包 成元组,如果使用多个变量接收返回值,python会自动将元组 拆包 成单个数据

    4 函数参数二

    a 默认参数

    • 形参设定默认值 称为 默认参数
    • 调用函数时,如果没有传入默认参数对应的实参,则实参使用默认值。
    def printinfo(name, age = 35):
       # 打印任何传入的字符串
       print("Name: %s", % name)
       print("Age: %s", % age)
    
    # 调用printinfo函数
    printinfo("miki")
    printinfo("miki", 20)
    
    • 注意:默认参数一定要位于参数列表的最后面。

    b 关键字参数(缺省参数)

    调用函数时,实参可以指定对应的形参,称为 关键字参数

    def printinfo(name, age):
       # 打印任何传入的字符串
       print("Name: %s", % name)
       print("Age: %s", % age)
    
    printinfo(age=9,name="miki" )
    

    c 可变参数

    1) args 元组可变参数

    • 函数可以定义 可变参数,用于接收任意数量的参数
    • 可变参数的前边需要添加*,用于提示python解释器该参数为可变参数
    • 使用可变参数直接用args即可(不需要加*)
    • 可变参数的本质是 将传递的参数包装成了元组
    def sum_num(a, b, *args):  
        result = a + b
        for temp in args:
            result += temp
    
        return result
    
    sum_num(1, 2, 3, 4, 5, 6)
    
    # 关键字参数一旦使用,所有实参都要使用,除非该实参对应的是可变参数
    # sum_num(1, 2, 3, 4, a=5)
    # sum_num(a=5, b=4)
    

    2)kwargs 字典可变参数

    • 字典可变参数:可以接受多余的关键字参数
    • 字典可变参数必须要放在形参的最后面
    • 定义参数时需要在变量名前添加两个*
    • 这种可变参数会将 不存在的关键字参数包装成字典
    def sum_num(a, b, *args, **kwargs):  
        print(a)
        print(b)
        print(args)
        print(kwargs)
    
    sum_num(1, 2, 3, 4, 5, 6, mm=5, nn=6)
    

    d函数的参数传递机制

    Python 中函数的参数传递机制都是“值传递”,就是将实际参数值的副本(复制品)传入函数,而参数本身不会受到任何影响。示例如下:

    # 传递可变参数
    def sum_num(a, b, *args, **kwargs):
        print(a)
        print(b)
        print(args)
        print(kwargs)
    
    def test(*args, **kwargs):
        print(args)
        print(kwargs)
    
    sum_num(1, 2, 3, 4, 5, 6, 7, mm=5, nn=6)
    
    

    5 总结

    Python 中的函数是“一等公民”,因此函数本身也是一个对象,函数即可用于赋值,也可用作其函数的参数,还可作为其他函数的返回值

    相关文章

      网友评论

        本文标题:python部分总结

        本文链接:https://www.haomeiwen.com/subject/oeyicktx.html