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)

>>> s1 = {11,22,33}>>> s2 = {22,33,44}>>> s1.difference_update(s2)>>> print(s1){11}

symmetric_difference      # 对称差集

    symmetric_difference( self ,  * args,  * * kwargs)

>>> s1 = {11,22,33}>>> s2 = {22,33,44}>>> s3 = s1.symmetric_difference(s2)>>> print(s3){33, 11, 44, 22}>>> s4 = s2.symmetric_difference(s1)>>> print(s4){33, 11, 44, 22}

symmetric_difference_update      # 对称差集，并更新到a中

    symmetric_difference_update( self ,  * args,  * * kwargs)

>>> s1 = {11,22,33}>>> s2 = {22,33,44}>>> s1.symmetric_difference_update(s2)>>> print(s1){33, 11, 44, 22}

discard     # 移除某个元素，不存在不报错

    discard( self ,  * args,  * * kwargs)

>>> s1 = {11,22,33}>>> s1.discard(11)>>> print(s1){33, 22}

remove     # 移除某个元素，不存在会报错

    remove( self ,  * args,  * * kwargs)

>>> s1 = {11,22,33}>>> s1.remove(11111)Traceback (most recent call last): File "<input>", line 1, in <module>KeyError: 11111>>> s1.remove(11)>>> print(s1){33, 22}

pop     # 随机移除某个元素

    pop( self ,  * args,  * * kwargs)

>>> s1 = {11,22,33}>>> ret = s1.pop()>>> print(ret)33>>> print(s1){11, 22}#ret为删除的值

intersection     # 取交集，共同都有的

    intersection( self ,  * args,  * * kwargs)

>>> s1 = {11,22,33}>>> s2 = {22,33,44}>>> s3 = s1.intersection(s2)>>> print(s3){33, 22}

intersection_update      # 取交集并更更新到A中

    intersection_update( self ,  * args,  * * kwargs)

>>> s1 = {11,22,33}>>> s2 = {22,33,44}>>> s1.intersection_update(s2)>>> print(s1){33, 22}

isdisjoint      # 如果没有交集，返回True，否则返回False

    isdisjoint( self ,  * args,  * * kwargs)

>>> s1 = {11,22,33}>>> s2 = {22,33,44}>>> s1.isdisjoint(s2)False#有交集返回False>>> s1 = {11,22,33}>>> s2 = {44,55,66}>>> s1.isdisjoint(s2)True#没有交集返回True

issubset      # 是否是子序列

    issubset( self ,  * args,  * * kwargs)

>>> s1 = {11,22,33}>>> s2 = {44,55,66}>>> s1.issubset(s2)False

issuperset      # 是否是父序列

    issuperset(self, *args, **kwargs)


>>> s1 = {11,22,33}>>> s2 = {44,55,66}>>> s1.issuperset(s2)False

union      # 并集

    union( self ,  * args,  * * kwargs)

>>> s1 = {11,22,33}>>> s2 = {22,33,44}>>> s3 = s1.union(s2)>>> print(s3){33, 22, 11, 44}

update     # 可以迭代

    update( self ,  * args,  * * kwargs)

>>> s1 = {11,22,33}>>> li = [11,22,3,11,2]>>> s1.update(li)>>> print(s1){3, 33, 2, 11, 22}>>> li = (11,22,3,11,2)>>> s1.update(li)>>> print(s1){3, 33, 2, 11, 22}>>> li = "sandler">>> s1.update(li)>>> print(s1){'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() #关闭文件

----------------------------------------------------------------------------------------------------

来自为知笔记(Wiz)

转载于:https://www.cnblogs.com/sandler613/p/5521456.html