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 = ' [email protected] '
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 - 类名（每个单词首字母大写）【驼峰标志法】