函数
‘‘‘
定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号，然后在缩进块中编写函数体，函数的返回值用return语句返回
定义函数： def f(a，b)：
return a ＋ b
参数可以赋默认值比如 a=0, b=0，参数也可以这样写: def f(*args)，即为参数可为任意值,例如：
def f (*args):
total = 0
for val in args:
total += val
return total
my_list = [1, 3, 5, 10, 20]
print(f(*mylist)) (把列表当作可变参数传到函数里面，要加*号，即把列表里面的元素进行操作)
‘‘‘
模块
‘‘‘
from 模块名 import 制定的函数
关键字：from， import， as
作用域－LEGB(local, enclose, global, build- in) 全局变量最好不要用
a = 100
def f():
global a
a = 200
b = ‘hello‘
def g():
nonlocal b
b = ‘good‘
‘‘‘
字符串
内存管理
‘‘‘
栈－变量－地址－对象的引用
堆－真正的对象
id()
is
静态区
（给服务器写程序，避免内存泄漏，防止崩溃）(python才用自动垃圾回收)
例子：
import sys list1 = [0]* 10 list2 = list1 list3 = list2 print(sys.getsizeof(list1)) print(sys.getrefcount(list1)) del list2 del list3 print(sys.getrefcount(list1))
‘‘‘
列表
‘‘‘
生成式的语法：mylist = [x ** 2 for x in range(1, 10)] （计算速度慢但是内存占用少）
mylist = mylist + [20, 30]
删除元素： del，remove
取出列表一部分－ 切片（起始位置，终止位置，步长）
列表排序： sort， 排好序的新列表：sorted
tuple和list 非常相似（获取元素的方法是一样的）但是tuple一旦初始化后就不能修改
‘‘‘
‘‘‘
生成器
通过列表生成式，我们可以直接创建一个列表，但是受内存限制，列表容量肯定是有限的，而且创建一个包含一百万个元素的列表，不仅占用很大的储存空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数的元素占用的空间都白白浪费了。所以如果列表元素可以按照某种方法推算出来，那么我们是否可以在循环中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在python中，一边循环一边计算的的机制，被称为生成器：generator
L = [x ** x for x in range(10)]
g = (x * x for x in range(10))
创建L和g的区别仅在于最外层的［］和（），L 是一个list，而g是一个generator。generator保存的是算法，每次调用next（g），就计算出下一个值，直到计算到最后一个元素，没有更多的元素时，抛出 StopIteration的错误。
斐波拉契数列用函数打印出来：
def fib(max):
n,a,b = 0,0,1
while n < max:
print(b)
a,b = b, a + b
n = n +1
return ‘done‘
‘‘‘
‘‘‘
迭代器
可以直接作用于for循环的数据类型有：list，tuple，dict，set，str等，一类是generator，包括生成器和带yield的generator function，这些可以直接作用于for循环的对象称为可迭代对象：Iterable。
‘‘‘
类和实例
‘‘‘
面向对象最重要的概念就是类（class）和实例（instance），类是抽象的模版，比如Student类，而实例是根据类创建出来的一个个具体的‘对象’，每个对象都拥有相同的方法，但各自的数据有可能不同。由于类可以起到模版的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去，通过定义一个特殊的函数‘__init__’方法，在创建实例的时候，就把name，score等属性绑定上去
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
注意到__init__方法的第一个参数永远是self，表示创建实例本身，因此在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。有了__init__方法，在创建实例的时候，就不能穿入空参数了，必须传入与__init__方法匹配的参数，但是self不需要传参，python解释器会自动把实例变量传进去。
面向对象编程的一个重要特点就是数据封装，在student类中，每个实例就拥有各自的name和score这些数据，我们可以通过函数来访问这些数据，比如打印一个学生的成绩：
def print_score(std):
... print(‘%s: %s‘ % (std.name, std.score))
...
>>> print_score(bart)
Bart Simpson: 59
但是，既然student实例本身就拥有这些数据，要访问这些数据，就没有必要从外面的函数去访问，可以直接在student类的内部定义访问数据的函数，这样就把‘数据’给封装起来了。这些封装数据的函数是和student类本身是关联起来的，我们称之为类的方法：
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
def print_score(self):
print(‘%s: %s‘ % (self.name, self.score))
我们从外部看student类，就只需要知道，创建实例需要给出name和score，而如何打印，都在student类内部定义的，这些数据和逻辑被封装起来了，调用很容易，但却不知道内部实现的细节。
封装的另一个好处是，可以给student类增加新的方法，比如get_grade：
class Student(object):
...
def get_grade(self):
if self.score >= 90:
return ‘A‘
elif self.score >= 60:
return ‘B‘
else:
return ‘C‘
小结：类是创建实例的模版，而实例则是一个个具体的对象，各个实例拥有的数据都相互独立，互不影响；
方法就是与实例绑定的函数，和普通函数不同，方法可以直接访问实例数据；
通过在实例上调用方法，我们就直接操作了对象内部的数据，但无需知道方法内部的实现细节；
和静态语言不同，python允许对实例变量绑定任何数据，也就是说，对于两个实例变量，虽然它们都是同一个类的不同实例，但拥有的变量名称都可能不同。
‘‘‘
例题：
1.约瑟夫环问题(30个人，有15个基督徒，数到9的人踢出去，最后剩下15个全是基督徒，问非基督徒的位置)
def main(): person = [True] * 30 #表示30个人都活着 counter = 0 # counter = 15 停止循环 index = 0 #第几个人在报数 number = 0 while counter < 15: if person[index]: number += 1 if number == 9: person[index] = False counter += 1 number = 0 index += 1 if index >= len(person): index = 0 for p in person: print(‘基督徒‘ if p else ‘不是基督徒‘, end=‘ ‘) if __name__ == ‘__main__‘: main()
2.用元组找出一个list里面第二大的数
def second_max(x): (m1, m2) = (x[0], x[1]) if x[0] > x[1] else (x[1], x[0]) for index in range(2, len(x)): if x[index] > m1: m2 = m1 m1 = x[index] elif m1 > x[index] > m2: m2 = x[index] return m2 def main(): my_list = [35,79,99,92,90,50,60,70,40,10,22,99,99] print(second_max(my_list)) if __name__ == ‘__main__‘: main()
3.设计一个函数，传入三个参数：年月日。返回传入的年月日是这一年的第几天
def is_leap_year(y): if y % 4 == 0 and y % 100 !=0 or y % 400 == 0: return True return False def which_day(year, month, day): days_of_month = [ [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] ][is_leap_year(year)] # 通过是否是闰年来返回bool值，bool值可返回0或者1 total = 0 for index in range(month - 1): total += days_of_month[index] return total + day if __name__ == ‘__main__‘: print(which_day(1908,11,28)) print(which_day(1908,3, 8)) print(which_day(1981,12,31))
def is_leap_year(y):ew Code
if y % 4 == 0 and y % 100 !=0 or y % 400 == 0:
return True
return False
def which_day(year, month, day):
days_of_month = [
[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
[31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
][is_leap_year(year)] # 通过是否是闰年来返回bool值，bool值可返回0或者1
total = 0
for index in range(month - 1):
total += days_of_month[index]
return total + day
if __name__ == ‘__main__‘:
print(which_day(1908,11,28))
print(which_day(1908,3, 8))
print(which_day(1981,12,31))
4.生成一个杨辉三角，给行数（例如10），生成杨辉三角
def triangle(): n = [1] while True: yield n n.append(0) n = [n[i - 1] + n[i] for i in range(len(n))] def num_triangle(): n = 0 for t in triangle(): print(t) n = n + 1 if n == 10: break if __name__ == ‘__main__‘: num_triangle()
5. 给定一个成绩列表，去掉最高分和最低分，求平均值
def main(): names = [‘刘备‘, ‘张飞‘, ‘赵云‘, ‘关羽‘, ‘诸葛亮‘, ‘曹操‘, ‘马超‘] score_list = [] total = 0 for name in names: score = input(‘请输入%s的成绩：‘ %name) score_list.append(score) min_score = max_score = score_list[0] for score in score_list: if score > max_score: max_score = score elif score < min_score: min_score = score total += int(score) score_list.remove(max_score) score_list.remove(min_score) print(‘平均成绩是：%.1f‘ %(total/len(score_list))) if __name__ == ‘__main__‘: main()
6. 双色球－ 6个红色球（1～33）和1个蓝色球（1～16）
from random import randrange, randint 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)) selectd_balls = [] for _ in range(6): index = randrange(0, len(red_balls)) selectd_balls.append(red_balls[index]) del red_balls[index] selectd_balls.sort() selectd_balls.append(randint(1,16)) return selectd_balls def main(): n = int(input(‘机选几注？‘)) for _ in range(n): display(random_select()) if __name__ == ‘__main__‘: main()
7. 十阶楼梯，小孩走可能一次走一级，或者两级也或者三级，问最多有多少走法
def foo(n): if n < 0: return 0 elif n == 0: return 1 return foo(n-1) + foo(n - 2) + foo(n - 3) if __name__ == ‘__main__‘: print(f(100)) print(foo(10))
8. 猜数字
from random import randint def main(): user_input = int(input("please input the number you want computer guess>>>:")) counter = 0 low = 1 high = 100 money = 1000 while True: guess = randint(low, high) print(guess) counter += 1 if user_input == guess: print("congratulation, computer guess right") print("total guess:", counter) money += 200 print("computer has: ", money) if money < 500: print(" computer you are fucking stupid!!!!") quit() elif user_input > guess: low = guess + 1 print("computer guess a higher number") money -= 100 else: # user_input < guess high = guess - 1 print("computer guess a lower number:") money -= 100 if __name__ == ‘__main__‘: main()