zoukankan      html  css  js  c++  java

  • 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 = "
" + 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'xe6x9dx8exe6x9dxb0'
    11. >>> bytes_name = bytes(name,encoding="gbk")
    12. >>> print(bytes_name)
    13. b'xc0xeexbdxdc'
    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'xc0xeexbdxdc'
    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()    #关闭文件
    ----------------------------------------------------------------------------------------------------
  • 相关阅读:
    DELPHI美化界面
    WebSevice相关
    Hotmail邮件接收
    DHTMLEdit
    Eclipse 基础
    POP3相关
    DELPHI中GIF的使用
    javaaop
    RAD Studio 2010 启动报错"displayNotification: 内存不够" 解决办法
    编程之道
  • 原文地址：https://www.cnblogs.com/sandler613/p/5521456.html
Copyright © 2011-2022 走看看