函数模块字符串列表

函数

'''

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

Vi

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))

ew Code

 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()