Python第二周学习总结

导读：这是python学习的第二周，在第二周，学习了大量的python基础，其中有字符串，列表，元祖，集合，字典，函数，面向对象编程。同时也做了大量的练习，了解了python基本的编程方法，形成了一定的编程思维逻辑能力。预计在下一周，将会花掉大量的时间来总结练习本周的内容，我自己的目标是：本周结束所有的基础过程，过度到python学习的较深入阶段，珍惜时间，善用时间，come on

函数

• 概念：函数是组织好的，可重复使用的，用来实现单一，或相关联的功能模块，函数能提高应用的模块性，和代码的重复利用率。

• 定义函数：def函数执行体，要有缩进，函数要有return语句或者yeild语句，运行函数看见return，就结束函数的运行。
  函数的参数也可以是可变参数：def(*args):

def main():
  a = 1
  b = 1
  return a + b
if __name__ = '__main__':
  main()

if name = 'main':该函数表示功能模块可以组装在一起使用，通过if条件可以在导入模块时不去执行下面的代码
在进入函数之前保存当前的执行任务

• 调用函数：方法：函数名（），理论上所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。使用递归函数还需要防止栈的溢出。

栈：在计算机中，函数调用时通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈栈帧，每当函数返回，栈就会减一层栈帧，由于栈的大小不是无限的，所以递归调用的次数过多，会导致栈溢出。

• 导入函数：from import
• 高阶函数：指函数里还有含有函数存在
• 文档注释：windows条件下：Ctrl + q 查看文档注释；I O S条件下：Ctrl + j；给函数添加文档注释（""" 换行不换行适情况而定 """），此外还可以用谷歌推荐的注释方法（""" Paraneters: \ n Returns: """"）
• 调试方法：可以分为单步跳过，单步进入
• 递归：函数直接或间接调用了自身，递归 - 回溯
  1，函数的执行现场是保存在栈的内存空间上
  2，栈是一种先进后出的（FILO）的存储结构
  3， 函数自己调用自己，一定要在有效的次数内停下来
• 实例：

10级别楼梯，上，选1,2,3。走完10级台阶，一共有多少种走法
思路：在第4级的时候，只有选择从第3级楼梯或者第2级楼梯或者第1级楼梯 共3种楼梯的方法，往下递推

def main(n):
    if n == 1:
        return 1
    elif n == 2:
        return 2
    elif n == 3:
        return 4
    else:
        return main(n - 1) + main(n - 2) + main(n - 3)
if __name__ == '__main__':
    print(main(10))

求阶乘 n! = n * (n - 1)!

#普通方法
def main():
  y = 1
  for z in range(x):
    y = y * z
  return y
if __name__ = '__main__':
  print(main(5))
#用函数调用的方式的实现求阶乘
def f(n):
  if n == 1:
    return 1
  else:
    return  n = n * f（n  - 1）
if __name__ = '__main__':
  print(f(5))

计算2个正整数的最大公约数 以及 最小公倍数
最小公倍数==2个数相乘 整除 它的最大公约数，又叫短除法

def gcd(x, y):
    """
    计算最大公约数
    :param x: 一个非负整数
    :param y: 一个非负整数
    :return: x,y最大公约数
    """
    (x, y) = (y, x) if x > y else (x, y)
    for factor in range(x, 0, -1):
        if x % factor == 0 and y % factor == 0:
            return factor
if __name__ == '__main__':
    print(gcd(60, 20))

def lcm(x, y):
    return x * y // gcd(x, y)

判断一个数是不是素数
思路：判断素数方法：如果这个数在 sqrt(n)之内都没有能整除的数，则这个数是一个素数

import math
def is_prime(num):
    for factor in range(2, int(math.sqrt(num))+ 1):
        if num % factor == 0:
            return False
    return True if num != 1 else False
print(is_prime(7))

判断一个整数是不是回文数。如12321
思路，如果个十百千万数倒过来与原始数字相同（将个位数的数字当做第一个数，最后加起来的数字），那么他就是回文数。难点：数字的倒转方法

def is_palindrome(num):
    total = 0
    temp = num
    while temp > 0:
        total = total * 10 + temp % 10
        temp //= 10
    return num == total
print(is_palindrome(12321))

判断一个字符串是不是回文字符串

思路：运用字符串的切片操作实现字符串的反转，同理数字也可以转换为字符串，进行操作。

def is_str(var1):
    var2 = var1[::-1]
    return var1 == var2
print(is_str('ABCDEDCBA')

21根火柴游戏：一次这能拿1-4根，人与电脑相互拿，谁拿到最后一根谁就输，要求保证计算机最后一定能获胜
思路：前20根火柴，一次性拿完，电脑每次拿走 5 - n 根火柴，那么第21根火柴必然是人拿走的，电脑就一定能赢

def main():
    total = 21
    while total > 0:
        print('总共还有多少%d根火柴' % total)
        while True:
            num = int(input('请输入你想拿取得火柴数：'))
            if 0 < num <= 4 and num <= total:
                break
        total -= num
        if total > 0:
            print('计算机拿走了%d根火柴' % (5 - num))
            total -= (5 - num)
        print('你输了')
if __name__ == '__main__':
    main()

运算符补充

• and or :and 和 or 都是带短路功能的运算符，
  1，如果and左边的表达式是False,那么右边的表达式被短路
  2，如果or左边的表示是True，那么右边的表达式被短路
  因此and 和 or 两边放置的表达式会对程序的执行效率产生影响

变量补充

1，LEGD法则：local 本地作用域；enlosing 嵌套作用域，global全局作用域，build-in .指的是内置作用域
2，如果想要改变变量的搜索范围：可以使用 global 和 nonlocal
2，法则使用：在实际开发时，要减少对全局变量的使用，也叫迪米特法则

字符串

• 字符串的常见用法

def main():
    #不变字符串
    help(''.capitalize)
    str1 = 'hello world!'#字符串的字面常量
    print(len(str1))
    print(str1.upper())#相当于把新的字符串给出来，并没有把原来字符串的对象作出改变
    print(str1.lower())
    print(str1)
    print(str1.find('shit'))# 找到的是位置，找不到的是-1
    print(str1.index('or'))
    print(str1.startswith('He')) #查看字符是不是以什么字母开头的
    print(str1.endswith('ld!'))  #查看结尾字符是以什么结尾的
    print(str1.center(50,'&')) #居中，一共50个字符
    print(str1.rjust(50,'*'))  #右对齐
    str2 = 'abcde123'
    print(str2[2:5:1]) #前面从0数数，后面从1开始数数
    print(str2[2:4])
    print(str2[-1:-3:-1])#range函数也可以写步长
    print(str2[::2])
    print(str2[::-1])#切片运算符，倒转
    print(str2.isdigit()) #判断数字
    print(str2.isalpha()) #判断字母
    print(str2.isalnum()) #判断数字字母
    str3 = '  jackasdad@136.com '
    print(str3)
    print(str3.strip()) #去掉左右两边空格，l 左边， r 右边

if __name__ == '__main__':
    main()

字符串跑马灯效果

import os
import time
def main():
    str1 = '欢迎来到千锋学习..........'
    while True:
        os.system('cls')
        print(str1)
        time.sleep(0.5)
        str1 = str1[1:] + str1[0]
        print(str1)
if __name__ == '__main__':
    main()

列表

• 列表的创建
  1，可以直接使用（list = [ ]）进行赋值
  2，list1 = list(range(10)) 创建对象的构造器
  3, list = [x ** x for x in range(1, 10)] 列表的生成表达式语法，浪费的是空间，节约的是时间
  4，list1 = (x ** x for x in range(1, 10)) 列表的生成器，浪费的是时间，节约的是空间
  5，变量在计算机中的存储大致可以分为3中：栈，堆，静态区
• 列表的基本使用方法

def main():
    f = [100, 200, 300]
    f.append(400)
    print(f)
    f.insert(1, 500)
    print(f)
    if 500 in f: #不知道元素的位置，，列表的in操作，用于判断元素是不是在列表里
        f.remove(500)
    print(f)
    del f[3]#知道位置，删除元素的方法
    print(f)
    f[1] = 2000
    print(f)
    #f.index(300, 3, 5) #判断元素是不在列表中,还可以制定查找的范围
    print(f)
    f.pop(1) #默认删除最后一个列表，还可以指定位置
    print(f)
if __name__ == '__main__':
    main()

使用列表一句话完成投骰子的操作
思路：实现了列表的生成，列表索引的使用

from random import randint

def main():
    list1 = [0] * 6
    for _ in range(6000):
        face = randint(1, 6)
        list1[face - 1] += 1
    return list1
if __name__ == '__main__':
    print(main())

双色球选号 - 红色球6个（1 - 33） 和 1蓝色球（1 - 16） 总：6红+1蓝

from random import randrange


def display(balls):
    for index, ball in enumerate(balls):#枚举类型
        if index == len(balls) - 1:
            print('|', end=' ')
        print('%02d' % ball, end=' ')
    print()


def random_select():
    red_balls = list(range(1, 34))
    select_balls = []
    for _ in range(6):
        index = randrange(len(red_balls))
        select_balls.append(red_balls[index])
        del red_balls[index]
    select_balls.sort()
    select_balls.append(randrange(1, 17))
    return select_balls

def main():
    n = int(input('机选几注：'))
    for _ in range(n):
        display(random_select())

if __name__ == '__main__':
    main()

30个人，谁报道9弄死，扔海里，继续报，直到剩下15个人，15个基督徒，15个非基督徒，。。求这些人位置怎么占的
思路：活着的为True，死掉的为False

def main():
    persons = [True] * 30
    counter = 0
    index = 0
    number = 0
    while counter < 15:
        if persons[index]:
            number += 1
            if number == 9:
                persons[index] = False
                counter += 1
                number = 0
        index += 1
        index = index % 30 #构成一个回环 if index == 30; index == 0
    for person in persons:
        print('计' if person else '非', end='')

if __name__ == '__main__':
    main()

字典

• 字典的基本使用

def main():#键值对
    dict1 = {'name': '骆昊', 'age': 38, 'gender': True}
    print(dict1['name'])
    print(dict1['age'])
    dict1['name'] = '王大锤'
    print(dict1)
    #dict1 += {'tel': '13511223344'}
    dict1.update(height= 174.5,fav=['吃','喝','玩'])
    dict1.pop('age')
    print(dict1.popitem())
    # del dict1#把原来建好的引用删除掉
    print(dict1)
    for val in dict1:
        print(val, '<---->', dict1[val])
    dict1.setdefault('motto', 'asd')#如果没有键值对，则放默认值，如果有，就用放置好的

if __name__ == '__main__':
    main()

用生成器实现斐波拉切系数

def fib(n):#也不会占用额外的空间，生成器的实现方式有2种
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
        yield a #没有return,有yield，这个函数不是一个普通的函数，这是一个生成器
f = fib(20) #**********************************很重要很重要
print(f)
for val in fib(20):
    print(val)

集合

• 集合的基本用法

def main():
    list1 = [1, 2, 2, 4, 5, 6]
    print(list1)
    tuple1 = (1, 2, 2, 4, 5, 6)
    print(tuple1)
    set1 = {1, 2, 2, 4, 5, 6}
    print(set1)
    set1.add(3)
    print(set1)
    set2 = {1, 3, 5, 7, 9}
    set3 = set1 & set2#交集
    #set3 = set1.intersection(set2)#交集
    print(set3)
    set3 = set1 | set2#并集
    #set3 = set.union(set1)#并集
    print(set1)
    set3 = set1 - set2
    #set3 = set1.difference(set2)#差集
    print(set3)

    set3 = set2.difference(set1)
    print(set3)
    set3 = set1 ^ set2#对称差
    #set3 = set1.symmetric_difference(set2)
    print(set3)
    for val in set2:#集合是离散存储的东西
        print(val)
    print(set2.pop())
    print(set1 <= set2)#运算符
    if 3 in set2:
        set2.remove(3)
    print(set2)
    print(set2.issubset(set1))
    print(set1.issuperset(set2))
    set4 = {1, 4}
    print(set1.issubset(set4))

if __name__ == '__main__':
    main()
#集合有去重的功能

元组

-元组的数据是不允许更改的

面向对象编程

• 1，类是对象的蓝图和模版，有了类就可以创建对象
  2，定义类需要做2件事情：数据抽象和行为抽象
  3，数据抽象- 抽取对象共同的静态特征 - 属性
  4，行为抽象- 抽取对象的共同的动态特征- 方法
  5，定义类的关键字 - class - 类名（每个单词首字母大写）【驼峰标志法】