Python之路_Day3

Python—Day3—课堂笔记
----------------------------------------------------------------------------------------------------
 前期回顾：
    Python简介
    Python入门
    内容编码
    注释
    脚本参数传入
    .pyc文件
    变量的声明
    用户输入(input)
    流程控制(if...else...，缩进，循环，break，continue)
    运算(+,-,*,/)
    基本数据类型(数字，字符串，布尔值)
    面向对象
    str,list,tuple,dict
----------------------------------------------------------------------------------------------------
本期大纲：
一、set集合
        —创建集合
        —集合功能及操作
        —练习
二、函数
— 自定义函数
        — 自定义函数小练习
— 内置函数
----------------------------------------------------------------------------------------------------
一、set集合
set集合是一个无序且不重复的序列
1、创建集合
li = ["12","34","56",]    #列表
dic = {"k":"v"}            #字典
se = {"123","456"}    #集合
  1. s1 = {11,22}
  2. s2 = set()
  3. s3 = set([11,22,33,4])
  1. >>> s = set()
  2. >>> li = [11,22,11,22]
  3. >>> s = set(li)
  4. >>> print(s)
  5. {11, 22}
2、集合功能及操作
add    #添加元素
    add(self, *args, **kwargs)
  1. >>> s = set()
  2. >>> print(s)
  3. set()
  4. >>> s.add(123)
  5. >>> print(s)
  6. {123}
clear    #清楚所有内容
    clear(self, *args, **kwargs)
  1. >>> s = {123}
  2. >>> print(s)
  3. {123}
  4. >>> s.clear()
  5. >>> print(s)
  6. set()
copy    #浅拷贝
    copy(self, *args, **kwargs)

difference    A中存在B中不存在
    difference(self, *args, **kwargs)
  1. >>> s1 = {11,22,33}
  2. >>> s2 = {22,33,44}
  3. >>> s3 = s1.difference(s2)
  4. >>> print(s3)
  5. {11}
  6. >>> s3 = s2.difference(s1)
  7. >>> print(s3)
  8. {44}
difference_update    #从当前集合中删除和B中相同的元素
    difference_update(self, *args, **kwargs)
  1. >>> s1 = {11,22,33}
  2. >>> s2 = {22,33,44}
  3. >>> s1.difference_update(s2)
  4. >>> print(s1)
  5. {11}
symmetric_difference    #对称差集
    symmetric_difference(self, *args, **kwargs)
  1. >>> s1 = {11,22,33}
  2. >>> s2 = {22,33,44}
  3. >>> s3 = s1.symmetric_difference(s2)
  4. >>> print(s3)
  5. {33, 11, 44, 22}
  6. >>> s4 = s2.symmetric_difference(s1)
  7. >>> print(s4)
  8. {33, 11, 44, 22}
symmetric_difference_update    #对称差集，并更新到a中
    symmetric_difference_update(self, *args, **kwargs)
  1. >>> s1 = {11,22,33}
  2. >>> s2 = {22,33,44}
  3. >>> s1.symmetric_difference_update(s2)
  4. >>> print(s1)
  5. {33, 11, 44, 22}
discard    #移除某个元素，不存在不报错
    discard(self, *args, **kwargs)
  1. >>> s1 = {11,22,33}
  2. >>> s1.discard(11)
  3. >>> print(s1)
  4. {33, 22}
remove    #移除某个元素，不存在会报错
    remove(self, *args, **kwargs)
  1. >>> s1 = {11,22,33}
  2. >>> s1.remove(11111)
  3. Traceback (most recent call last):
  4.   File "<input>", line 1, in <module>
  5. KeyError: 11111
  6. >>> s1.remove(11)
  7. >>> print(s1)
  8. {33, 22}
pop    #随机移除某个元素
    pop(self, *args, **kwargs)
  1. >>> s1 = {11,22,33}
  2. >>> ret = s1.pop()
  3. >>> print(ret)
  4. 33
  5. >>> print(s1)
  6. {11, 22}
  7. #ret为删除的值
intersection    #取交集，共同都有的
    intersection(self, *args, **kwargs)
  1. >>> s1 = {11,22,33}
  2. >>> s2 = {22,33,44}
  3. >>> s3 = s1.intersection(s2)
  4. >>> print(s3)
  5. {33, 22}
intersection_update    #取交集并更更新到A中
    intersection_update(self, *args, **kwargs)
  1. >>> s1 = {11,22,33}
  2. >>> s2 = {22,33,44}
  3. >>> s1.intersection_update(s2)
  4. >>> print(s1)
  5. {33, 22}
isdisjoint    #如果没有交集，返回True，否则返回False
    isdisjoint(self, *args, **kwargs)
  1. >>> s1 = {11,22,33}
  2. >>> s2 = {22,33,44}
  3. >>> s1.isdisjoint(s2)
  4. False
  5. #有交集返回False
  6. >>> s1 = {11,22,33}
  7. >>> s2 = {44,55,66}
  8. >>> s1.isdisjoint(s2)
  9. True
  10. #没有交集返回True
issubset    #是否是子序列
    issubset(self, *args, **kwargs)
  1. >>> s1 = {11,22,33}
  2. >>> s2 = {44,55,66}
  3. >>> s1.issubset(s2)
  4. False
issuperset    #是否是父序列
    issuperset(self, *args, **kwargs)
  1. >>> s1 = {11,22,33}
  2. >>> s2 = {44,55,66}
  3. >>> s1.issuperset(s2)
  4. False
union    #并集
    union(self, *args, **kwargs)
  1. >>> s1 = {11,22,33}
  2. >>> s2 = {22,33,44}
  3. >>> s3 = s1.union(s2)
  4. >>> print(s3)
  5. {33, 22, 11, 44}
update    #可以迭代
    update(self, *args, **kwargs)
  1. >>> s1 = {11,22,33}
  2. >>> li = [11,22,3,11,2]
  3. >>> s1.update(li)
  4. >>> print(s1)
  5. {3, 33, 2, 11, 22}
  6. >>> li = (11,22,3,11,2)
  7. >>> s1.update(li)
  8. >>> print(s1)
  9. {3, 33, 2, 11, 22}
  10. >>> li = "sandler"
  11. >>> s1.update(li)
  12. >>> print(s1)
  13. {'a', 33, 2, 3, 'd', 'l', 'e', 11, 's', 22, 'r', 'n'}
3、练习
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # by sandler
  5. old_dice = {
  6.     "#1":8,
  7.     "#2":4,
  8.     "#4":2,
  9. }
  11. new_dice = {
  12.     "#1":4,
  13.     "#2":4,
  14.     "#3":2,
  15. }
  17. #应该删除那几个槽位
  18. #应该更新那几个槽位
  19. #应该增加那几个槽位
  21. new_set = set(new_dice.keys())
  22. old_set = set(old_dice.keys())
  23. remove_set = old_set.difference(new_set)
  24. add_set =  new_set.difference(old_set)
  25. update_set = old_set.intersection(new_set)
----------------------------------------------------------------------------------------------------
二、函数
1、自定义函数
1)使用：
    (1)、def关键字，创建函数
    (2)、函数名
    (3)、():
    (4)、函数体
    (5)、返回值
    def 函数名():
        函数体
        返回值
    函数示例，邮件发送：
  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. # By Sandler
  5. def sendmail():
  6.     try:
  7.         import smtplib
  8.         from email.mime.text import MIMEText
  9.         from email.utils import formataddr
  10.         msg = MIMEText('邮件内容', 'plain', 'utf-8')
  11.         msg['From'] = formataddr(["武沛齐",'wptawy@126.com'])
  12.         msg['To'] = formataddr(["走人",'424662508@qq.com'])
  13.         msg['Subject'] = "主题"
  15.         server = smtplib.SMTP("smtp.126.com", 25)
  16.         server.login("wptawy@126.com", "邮箱密码")
  17.         server.sendmail('wptawy@126.com', ['3628905@qq.com',], msg.as_string())
  18.         server.quit()
  19.     except:
  20.         # 发送失败
  21.         return "失败"
  22.     else:
  23.         # 发送成功
  24.         return "cc"
  25. ret = sendmail()
  27. print(ret)
  28. if ret == "cc":
  29.     print('发送成功')
  30. else:
  31.     print("发送失败")
2)参数：
    普通参数(严格按照顺序，将实际参数赋值给形式参数)
  1. >>> def f1(name):
  2. ...     print(name)
  3. ...     
  4. >>> f1('sandler')
  5. sandler
  7. >>> def f1(name,age):
  8. ...     print(name)
  9. ...     print(age)
  10. ...     
  11. >>> f1('sandler',18)
  12. sandler
  13. 18
    默认参数(必须放置在参数列表最后)
  1. >>> def f1(name,age,job='IT'):
  2. ...     print(name)
  3. ...     print(age)
  4. ...     print(job)
  5. ...     
  6. >>> f1("sandler",18)
  7. sandler
  8. 18
  9. IT
  10. >>> f1("sandler",18,"HR")
  11. sandler
  12. 18
  13. HR
    指定参数(将实际参数赋值给定值的形式参数)
  1. >>> def f1(name,age,job='IT'):
  2. ...     print(name)
  3. ...     print(age)
  4. ...     print(job)
  5. ...     
  6. >>> f1(age=18,name="sandler",job="HR")
  7. sandler
  8. 18
  9. HR
    动态参数
        '*args'(可以传入多个参数，转换成元祖，如果传入一个列表，则会把整个列表转化成一个元祖的元素，但如果列表前加上*，则会把列表的每一个元素转化成元祖的元素)
  1. >>> def f1(*args):
  2. ...     print(args,type(args))
  3. ...     
  4. >>> f1(11)
  5. (11,) <class 'tuple'>
  6. >>> li = [11,22,33,44]
  7. >>> f1(li)
  8. ([11, 22, 33, 44],) <class 'tuple'>
  9. >>> f1(*li)
  10. (11, 22, 33, 44) <class 'tuple'>
  11. >>> li = "sandler"
  12. >>> f1(*li)
  13. ('s', 'a', 'n', 'd', 'l', 'e', 'r') <class 'tuple'>
        '**args'(动态指定参数，指定某个key和value，例：n1="sandler"，传入后转化为字典，)
  1. >>> def f1(**args):
  2. ...     print(args,type(args))
  3. ...     
  4. >>> f1(k1="v1")
  5. {'k1': 'v1'} <class 'dict'>
  6. >>> dic = { "k1":"v1","k2":"v2"}
  7. >>> f1(kk=dic)
  8. {'kk': {'k2': 'v2', 'k1': 'v1'}} <class 'dict'>
  9. >>> f1(**dic)
  10. {'k2': 'v2', 'k1': 'v1'} <class 'dict'>
    万能参数(*args,**kwargs)
  1. >>> def f1(*args,**kwargs):
  2. ...     print(args,type(args))
  3. ...     print(kwargs,type(kwargs))
  4. ...     
  5. >>> f1(11,22,33,44,k1="v1",k2="v2")
  6. (11, 22, 33, 44) <class 'tuple'>
  7. {'k1': 'v1', 'k2': 'v2'} <class 'dict'>
3)补充：
    字符串格式化: .format(*args,**kwargs)
  1. >>> s1 = "i am {0}, age {1}.".format("sandler", 18)
  2. >>> print(s1)
  3. i am sandler, age 18.
  5. >>> s2 = "i am {0}, age {1}".format(*["sandler", 18])
  6. >>> print(s2)
  7. i am sandler, age 18
  9. >>> s1 = "i am {name}, age {age}".format(name='sandler', age=18)
  10. >>> print(s1)
  11. i am sandler, age 18
  13. >>> dic = {'name': 'sandler', "age": 18}
  14. >>> s2 = "i am {name}, age {age}".format(**dic)
  15. >>> print(s2)
  16. i am sandler, age 18
    全局变量：所有的作用域都可读，优先使用自己作用域的变量，
        全局变量的变量名需要全部大写（潜规则）
        对全局变量进行重新赋值，需要global
        global 变量名 在任意作用域定义全局变量
        特殊：列表字典，可修改，不可重新赋值
  1. #!/usr/bin/env python
  2. #    -.-    coding: utf-8    -.-
  3. # By sandler
  4. '''
  5. def f1():
  6.     name = "alex"
  7.     print(name)
  9. def f2():
  10.     print(name)
  11. name变量定义在f1函数中，所以只有f1函数可以读取，f2函数无法读取name变量
  12. '''
  14. NAME = "sandler"
  16. def f1():
  17.     age = 18
  18.     print(NAME,age)
  20. def f2():
  21.     age = 19
  22.     print(NAME,age)
  23. f1()
  24. f2()
  26. def f3():
  27.     age = 18
  28.     global NAME # 表示，name是全局变量
  29.     NAME = "yuli"
  30.     print(age, NAME)
  32. def f4():
  33.     age = 19
  34.     print(age, NAME)
  35. f3()
  36. f4()
4)三元运算：对于简单的 if else 语句，可以使用三元运算来表示，即：
  1. if 1 == 1:
  2.     name = "sandler"
  3. else:
  4.     name = "yuli"
  6. name = "sandler" if 1 == 1 else "yuli"
5)lambda表达式：简单的函数，只能用一行
  1. def func(arg):
  2.     return arg + 1
  3. result = func(123)
  5. my_lambda = lambda arg : arg + 1
  6. result = my_lambda(123)
2、自定义函数小练习
编写一个用户登录程序，程序包含用户登录和用户注册，利用函数编写：
  1. #!/usr/bin/env python
  2. # -.- coding:utf-8 -.-
  3. # By Sandler
  6. def login(username, password):
  7.     """
  8.     用于用户登录
  9.     :param username: 用户输入的用户名
  10.     :param password: 用户输入的密码
  11.     :return: true，表示登录成功；false，登录失败
  12.     """
  13.     f = open("db", 'r')
  14.     for line in f:
  15.         line_list = line.strip().split("|")
  16.         if line_list[0] == username and line_list[1] == password:
  17.             return True
  18.     return False
  21. def register(username, password):
  22.     """
  23.     用于用户注册
  24.     :param username: 用户输入的用户名
  25.     :param password: 用户输入的密码
  26.     :return: 默认None
  27.     """
  28.     f = open("db", 'a')
  29.     temp = "\n" + username + "|" + password
  30.     f.write(temp)
  31.     f.close()
  34. def main():
  35.     t = input("1、登录；2、注册 ： ")
  36.     if t == "1":
  37.         user = input("请输入用户名： ")
  38.         pwd = input("请输入密码： ")
  39.         r = login(user, pwd)
  40.         if r:
  41.             print("登录成功")
  42.         else:
  43.             print("登录失败")
  44.     elif t == "2":
  45.         user = input("请输入用户名： ")
  46.         pwd = input("请输入密码： ")
  47.         register(user, pwd)
  49. main()
3、内置函数
注：查看详细猛击这里
abs()    绝对值
  1. >>> num = abs(3)
  2. >>> print(num)
  3. 3
all()    所有为真，才为真
  1. >>> num = all([1,2,3,None])
  2. >>> print(num)
  3. False
  4. >>> num = all([1,2,3])
  5. >>> print(num)
  6. True
any()    只要有真，就为真
  1. >>> num = any([[],0,"",None])
  2. >>> print(num)
  3. False
  4. >>> num = any([[],1,"",None])
  5. >>> print(num)
  6. True
ascii()    忘掉他吧
  1. # 按大王的至理名言来说”忘掉他吧“
  2. >>> class Foo:
  3. ...     def __repr__(self):
  4. ...         return "444"
  5. ...         
  6. >>> num = ascii(Foo())
  7. >>> print(num)
  8. 444
bin()    十进制转二进制
  1. >>> print(bin(8))
  2. 0b1000
oct()    十进制转八进制
  1. >>> print(oct(12))
  2. 0o14
hex()    十进制转十六进制
  1. >>> print(hex(14))
  2. 0xe
bool()    布尔值，真或假
  1. >>> print(bool(1))
  2. True
  3. >>> print(bool(0))
  4. False
  5. >>> print(bool(None))
  6. False
  7. >>> print(bool(()))
  8. False
  9. >>> print(bool([]))
  10. False
  11. >>> print(bool({}))
  12. False
bytes()    把字符串转换成字节类型,需要定义编码格式 例“n = bytes("李杰",encoding="utf-8")”
  1. # utf-8 一个汉字：三个字节
  2. # gbk 一个汉字：二个字节
  3. # 字符串转换字节类型
  4. # bytes(只要转换的字符串， 按照什么编码）
  5. >>> name = "李杰"
  6. >>> print(name)
  7. 李杰
  8. >>> bytes_name = bytes(name,encoding="utf-8")
  9. >>> print(bytes_name)
  10. b'\xe6\x9d\x8e\xe6\x9d\xb0'
  11. >>> bytes_name = bytes(name,encoding="gbk")
  12. >>> print(bytes_name)
  13. b'\xc0\xee\xbd\xdc'
str()    把字节转换成字符串str(bytes("李杰",encoding="utf-8"),encoding="utf-8")
  1. >>> name = "李杰"
  2. >>> print(name)
  3. 李杰
  4. >>> bytes_name = bytes(name,encoding="gbk")
  5. >>> print(bytes_name)
  6. b'\xc0\xee\xbd\xdc'
  7. >>> str_name = str(bytes_name,encoding="gbk")
  8. >>> print(str_name)
  9. 李杰
open()    文件处理操作
    操作文件是一般分为：打开文件、操作文件、关闭文件
    (1)打开文件：
  1. 文件句柄 = open('文件路径', '模式')
    打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。
    打开文件的模式有：
        r ，只读模式【默认】
        w，只写模式【不可读；不存在则创建；存在则清空内容；】
        x， 只写模式【不可读；不存在则创建，存在则报错】
        a， 追加模式【可读；   不存在则创建；存在则只追加内容；】

        "+" 表示可以同时读写某个文件
        r+， 读写【可读，可写】
        w+，写读【可读，可写】
        x+ ，写读【可读，可写】
        a+， 写读【可读，可写】

        "b"表示以字节的方式操作
        rb  或 r+b
        wb 或 w+b
        xb 或 w+b
        ab 或 a+b
        注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型
  1. f = open('db', 'r') # 只读
  2. f = open('db', 'w') # 只写，先清空原文件
  3. f = open('db', 'x') # 文件存在，报错；不存在，创建并只写
  4. f = open('db', 'a') # 追加
  5. f = open('db','r', encoding="utf-8")
    (2)操作文件：
        close(self, *args, **kwargs)    #关闭文件
  1. #!/usr/bin/env python
  2. # -.- coding:utf-8 -.-
  3. # By Sandler
  5. f = open("db","r")    #打开文件
  6. f.read()    #读取文件
  7. f.close()    #关闭文件
        fileno(self, *args, **kwargs)    #文件描述符
  1. #! /usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By Sandler
  5. f = open("db", 'r+')
  6. f.fileno()
        flush(self, *args, **kwargs)    #刷新文件内部缓冲区
  1. #!/usr/bin/env python
  2. # -.- coding:utf-8 -.-
  3. # By Sandler
  5. f = open("db", 'a')
  6. f.write("123")
  7. f.flush()    #强制刷新写入上面的内容
  8. input("请输入： ")    #等待用户输入
        isatty(self, *args, **kwargs)    #判断文件是否是同意tty设备
        read(self, *args, **kwargs)    #读取指定字节数据
  1. #!/usr/bin/env python
  2. # -.- coding:utf-8 -.-
  3. # By Sandler
  5. f = open("db","r")
  6. data = f.read()
  7. print(data)
  8. f.close()
        readable(self, *args, **kwargs)    #是否可读
        readline(self, *args, **kwargs)    #仅读取一行数据
  1. #!/usr/bin/env python
  2. # -.- coding:utf-8 -.-
  3. # By Sandler
  5. f = open("db","r")
  6. for line in f:
  7.     print(line)    #按行打印文件内容
  8. f.close()
        seek(self, *args, **kwargs)    #指定文件中指针位置
  1. #!/usr/bin/env python
  2. # -.- coding:utf-8 -.-
  3. # By Sandler
  5. f = open("db","r")
  6. f.seek(3)    #指定指针位置为第三个字节
        seekable(self, *args, **kwargs)    #指针是否可操作
        tell(self, *args, **kwargs)    #获取指针位置
  1. #!/usr/bin/env python
  2. # -.- coding:utf-8 -.-
  3. # By Sandler
  5. f = open("db","r")
  6. print(f.tell())    #打印当前指针位置(字节)
        truncate(self, *args, **kwargs)    #截断数据，仅保留指定之前数据
  1. #!/usr/bin/env python
  2. # -.- coding:utf-8 -.-
  3. # By Sandler
  5. f = open("db", 'r+')
  6. f.seek(3)    #指定指针位置
  7. f.truncate()    #截断，指针位置后的数据清空
  8. f.close()
        writable(self, *args, **kwargs)    #是否可写
        write(self, *args, **kwargs)    #写内容
  1. #! /usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By Sandler
  5. f = open("db", 'w')    #打开文件
  6. f.write("yuli")    #先清空文件内容，再写入文件
  7. f.close()    #关闭文件
  9. f = open("db", 'a')    #打开文件
  10. f.write("alice")    #追加写入文件到最后一行
  11. f.close()    #关闭文件
----------------------------------------------------------------------------------------------------





posted @ 2016-05-23 21:20  滚动的沙砾  阅读(247)  评论(0)    收藏  举报