函数模块字符串列表

函数

'''

定义一个函数要使用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):
    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()