第二周：python中的函数，模块等与面向对象基本概念

函数

在介绍函数之前，我们试着用之前学过的if或while来写求一个数的阶乘的代码：

m = int(input('请输入一个数字'))
fm = 1
for num in range(1, m+1):
    fm *= num
print(fm)

这是求一个数的情况，如果是多个数呢？那这段代码将变得极其长并且重复。这对于程序员来说无疑是一件重复劳累且没有任何意义的操作。而且对于代码来说，它也产生了“最坏的味道——重复”。那我们怎么才能做到缩短代码，甚至在以后需要用到它的时候随时可以用，而不用去粘贴复制再改里面的参数这么麻烦呢？这时候就需要引入函数和模块的概念。

我们可以把程序中相对独立的模块抽取出来，这样做的好处一是可以减少重复代码，二是将来可以重复使用这些功能模块。python中的函数就代表了这样的功能模块。

python中定义函数的格式为：

def f(m)
    z = 1
    for num in range(1, m + 1):
    z *= num
    return z

在以上这段代码中，fm为因变量，m为自变量，这其实与数学中函数类似。返回的也是因变量的值。值得注意的是自变量和因变量都是可有可无的。没有自变量就空在那里。
好了，如果我们要算几个数的阶乘相除，就不用再大段地写重复代码了，只需要调用我们已经写好的函数就行了：

def f(m)
    z = 1
    for num in range(1, m + 1):
    z *= num
    return z

x = int(input('请输入数字：'))
y = int(input('请输入数字：'))
print(f(x)/f(y))

函数的调用

从上面的例子我们可以知道，当我们写好一个函数模块之后，我们想要用调用它的话，就直接将变量代进函数中就可以了。但这是在同一个程序下。我们前面也说过，我们希望在任何时候都可以调用我们已经写好的函数，那这又如何实现呢？调用模式如下：

from () import （） #第一个括号里写上文件名就行了，第二个括号里写希望调出的函数

当然，python中也有很多内置模块，比如time模块，math模块，random等等。我们也可以用以上语句来调用。
但是，值得注意的是，我们调用上一个文件中的函数的时候，如果上一文件的执行代码前没有加入以下这句话，那么你把函数调入时，程序会继续执行上一文件中的代码：

if __name__ == '__main__':

今后，所有执行代码都写在这下面。

如果导入相同模块，只会执行下面那个。但如果写成下图这样，可以分开执行，但后面的函数会覆盖前面的，同样，如果调用别的模块里的相同函数名，也只能调出后面的函数。

a = 100

def foo():
    a = 200
    print(a)

foo()
print(a)

运行结果如下：

如果想要在函数里用外面的变量，需要在函数里加入global + 变量名字来实现。同时，在Python中，是支持函数嵌套的（搜索顺序：Local —— Enclosed — Global,如果想要改变索索范围，可以使用global和nonlocal关键字，在写代码过程中，要减少全局变量的使用）

字符串

def main():
    #不变字符串
    str1 = 'hello, world'
    print(len(str1))
    print(str1.capitalize())
    print(str1.upper())
    print(str1)
    print(str1.find('or'))#查找or位置
    print(str1.rfind('r'))#从右往左找
    print(str1.index('or'))
    # print(str1.index('shit'))
    # print(str1.startswith('HE'))
    print(str1.startswith('he'))
    print(str1.endswith('d'))
    print(str1.center(50,'*'))#把字符串放中间，两边用*填充，加上字符串一共50
    print(str1.rjust(50,'*'))#            右边，左边用*
    str2 = "abc123456"
    print(str2[2:5])#冒号前是从0开始数，冒号后是从1开始数
    print(str2[-1:-3:-1])#表示从后面往前取
    print(str2[-3:-1])
    print(str2[2:])#表示从第二个开始取完
    print(str2[2::2])
    print(str2[::2])#冒号表示取完
    print(str2[::-1])
    print(str2.isdigit())#查找是否全是数字
    print(str2.isalpha())#查找是否全是字母
    print(str2.isalnum())#查找是否由数字和字母组成
    str3 = '  555555@qq.com   '
    print(str3.strip())#去掉左右两边空格

以上就是字符串常用的操作。

列表

有了列表（容器）我们可以使用一个变量来保存多个数据，更为重要的是我们可以使用循环对列表中保存的数据进行操作。

• 列表的生成式语法创造

mylist = [x ** 2 for x in range(1, 10)]

• 列表生成器语法

 f = (x ** x for x in range(1,10))
  ```
创造生成器：
 ```
 def fib(n):
    a, b = 0, 1
    for _ in range(n):
    a, b = b, a + b
    yield a

for val in fib(20):
    print(val)
#斐波拉切数列

• 构造列表的方法有：

def mian():
    f = list(range(10))
    print(f)
    f = [x for x in range(10)]
    print(f)
    f = [x ** x for x in range(1,10)
    print(f)
    f = (x ** x for x in range(1,10))
    print(f)
    for val in f:
        print(val)

• 列表的排序：

def main():
    f = ['orange', 'apple', 'bannana', 'pitaya', 'blueberry']
    f2 = sorted(f, reverse=True)#如果要按照长度f2 = sorted(f,k=len) 
    print(f)
    print(f2)
if __name__ == '__main_-'；
    main()  

1. python中内置的排序方法都是排升序（从小到大）
2. 如果想要改为降序（从大到小），可以使用reverse参数来指令
   python中的函数几乎都是没有副作用的函数（调用函数之后不会影响传入的参数）
3. key表示你以什么标准来排序
4. 列表增加元素除了appden，还可以直接加上：

mylist = mylist + [20, 30]

1. 看元素是否在列表中，使用in
2. 排序：mylist.sort()这种要改变原列表

内存管理

栈 - 变量 - 地址 - 对象的引用

堆 - 真正的对象

python用的是自动的内存管理。

举例说明：

list1 = [0] * 10
list2 = list1

list1一直在被引用，就不会被垃圾回收机制回收。

impor sys


list1 = [0] * 10
list2 = list1#如果改成list2 = list2[:],后面表示切片，不算引用计数。
list3 = list2
print(sys.getsizeof(list1)
print(sys.getrefcount(list1)
del list2
del list3
print(sys.getrefcount(list1)

以上代码主要是为了了解对象引用计数的值，打印出来的数减1，就是正确的引用计数

元组

创建元组的性能要远远高于创建列表。但是元组不能改变。
tuple = (1, 2, 4, 5)
元组使用的是圆括号，而列表使用的是综括号。
如果想要放入不同的数据类型，比如又有字符串又有数字布尔值之类的，并且我们能保证只去读取，不去做修改，那我们一般建议使用元组而不用列表。

集合

def main():
    list1 = [1, 1, 2, 2, 3, 3]
    tuple = (1, 1, 2, 2, 3, 3)
    set1 = {1, 1, 2, 2, 3, 3}
    print(set1)#此时打印结果，只会显示1，2 3。
    set2 = {1, 3 ,5, 7, 9}
    set3 = set1.intersection(set2)#求两个集合的交集
    set3 = set1.union(set2)#求两个集合的并集
    set3 = set1.difference(set2)求个集合的差集，set1 - set2
    set3 = set2.difference(set1)#求两个集合的差集，set2 - set1
    set3 = set1.symmetric(set2)#求两个集合的对称差集

    for val in set2：
        print(val)
    if 3 in set2:
        set2.remove(3)
    print(set2)

1. 集合中不允许出现重复元素
2. 集合是没有索引（下标）运算的，因为集合中元素没有顺序
3. 集合求交集，差集，并集，对称差等可以直接使用运算符（&，- ， | ，^)
4. 集合可以排序，但排完序之后就会变成列表。
5. 列表集合元组之间可以相互转换

字典

字典是一种可变容器模型，它可以储存所有类型的对象。字典中的元素是有键值对组成，一个键对应一个值，通过冒号 将他们分开。以下是字典的一些用法：

def main():
    dict1 = {'sjy:30', 'xxz':10}
    print(dict1['sjy'])
    print(dict1['xxz'])
    dict1['sjy'] = 40#更新字典中元素
    print(dict1)
    for x in dict1:
        print(x,'--->', dict1[x])#字典的遍历，用箭来表示
    if 'xxz' in scores:
        print(dict1['xxz'])
    print(dict1.get('xxz'))
    # get方法也是通过键获取对应的值但是可以设置默认值
    print(dict1.get('xxz', 60))
    # 删除字典中的元素
    print(dict1.popitem())
    print(dict1.popitem())
    print(dict1.pop('xxz', 1))        

面向对象

1. 对象都是独一无二的
2. 对象都可以归属到一个类（类是抽象的，对象是具体的）

创建类

#1.定义类
#类是对象的蓝图和模块 有了类就可以创建对象
#定义类需要做两件事：数据抽象和行为抽象
#数据抽象 - 抽取对象共同的静态特征（找名词）-属性
#行为抽象—抽取对象共同的动态特征（找动词）—方法
#定义类的关键字 - class - 类名（每个单词的首字母大写）
class Student:
#构造方法(构造器/构造字 - constructor)
#调用该方法的时候不是直接使用方法的名字而是使用类的名字
    def __init__(self, name, age):
        self.name = name
        self.age = age
#我们定义一个方法就代表对象可以接收这个消息
#对象的方法的第一个参数都是统一写成self
#它代表了接收消息的对象 - 对象.消息（参数）

   def sutdy(self,course):#括号里的self是自动补全的。类里面的函数，一般称为方法，这里表示让学生学习。
        print('%s正在学习%s' % self.name,course)

    def watch_av(self):
        print('%s正在观看岛国爱情动作片' % self.name)


def main():
#第二步：调用构造方法创建学生对象
#实际上调用的是student
    stu1 = Student('sjy', 25)
#第三步：给对象发消息
#通过给对象发消息让对象完成某些工作
#解决任何问题都是通过让对象去做事情
    stu1.study('语文')
    stu2 = Student('xxz', 30)
    stu2.watch_av()


if __name__ == '__main__':
    main()

#def __str__(self):
    return
#这个方法可以获得对象的字符串表示形式
#当我们用print打印对象时会自动调用该方法

1. 例题一，描述平面上的点：

from math import sqrt


class Point(object):

    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def move_to(self, x, y):
        self.x = x
        self.y = y

    def move_by(self, dx, dy):
        self.x += dx
        self.y += dy

    def distance_to(self, other):
        dx = self.x - other.x
        dy = self.y - other.y
        return sqrt(dx ** 2 + dy ** 2)

    def __str__(self):
        return '(%s, %s)' % (str(self.x), str(self.y))


def main():
    p1 = Point()
    p2 = Point(5, 3)
    print(p1.distance_to(p2))
    p1.move_to(3,4)
    print(p1)
    p1.move_by(3,4)
    print(p1)



if __name__ == '__main__':
    main()

1. 在屏幕上打出时间，并且时间与当前时间一致：

import time


def loc_time():
    time.time()
    time.localtime(time.time())
    return time.strftime('%H:%M:%S', time.localtime(time.time()))


class Clock(object):

    def __init__(self,hour = 0, minute = 0, second = 0):
        self.hour = hour
        self.minute = minute
        self.second = second

    def run(self):
        self.second += 1
        if self.second == 60:
            self.second = 0
            self.second += 1
            if self.minute == 60:
                self.minute = 0
                self.minute += 1
                if self.hour == 24:
                    self.hour = 0
                    self.hour += 1


    def __str__(self):
        return '%02d:%02d:%02d' % (self.hour, self.minute,self.second)

def main():
    while True:
        print(loc_time())
        time.sleep(1)

if __name__ == '__main__':
    main()