Python学习之旅 —— 基础篇(三)set集合、函数、文件操作

本篇要点:

数据类型:set集合

函数

文件操作

三元运算(三目运算)和lambda表达式

一、set集合

python中数据类型的一种,是无序并且不重复的数据集合。set源码:

class set(object):
    """
     创建set集合
    set() -> new empty set object
     把可迭代的数据类型转换成元组
    set(iterable) -> new set object

    Build an unordered collection of unique elements.
    """

>>> s1 = {11, 22, 33}
>>> print(s1,type(s1))
{33, 11, 22} <class ‘set‘>

>>> l1 = [2, 3, 4,]
>>> s1 = set(l1)
>>> print(l1,type(l1))
[2, 3, 4] <class ‘list‘>
>>> print(s1,type(s1))
{2, 3, 4} <class ‘set‘>

    # 向集合中增加元素,如果存在,不做任何操作。
    def add(self, *args, **kwargs): # real signature unknown
        """
        Add an element to a set.

        This has no effect if the element is already present.
        """
        pass

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

# 清空集合中所有的元素
    def clear(self, *args, **kwargs): # real signature unknown
        """ Remove all elements from this set. """
        pass

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

# 浅复制一个集合 只拷贝第一层
    def copy(self, *args, **kwargs): # real signature unknown
        """ Return a shallow copy of a set. """
        pass

    # s1.difference(s2) 找到在s1中有,s2中没有的元素,并保存到一个新的集合
    def difference(self, *args, **kwargs): # real signature unknown
        """
        Return the difference of two or more sets as a new set.

        (i.e. all elements that are in this set but not the others.)
        """
        pass

>>> s1 = {11,22,33,}
>>> s2 = {22,33,44,}
>>> s3 = s1.difference(s2)
>>> print("%s \n%s \n%s" % (s1,s2,s3))
{33, 11, 22}
{33, 44, 22}
{11}

# s1.difference(s2) 找到在s1中有,s2中没有的元素,把结果更新到s1中
    def difference_update(self, *args, **kwargs): # real signature unknown
        """ Remove all elements of another set from this set. """
        pass

>>> s1 = {11,22,33,}
>>> s2 = {22,33,44,}
>>> s1.difference_update(s2)
>>> print("%s \n%s" % (s1,s2))
{11}
{33, 44, 22}

# s1.intersection(s2) 找到即在集合s1中,又在集合s2中的元素,并把结果保存到一个新的集合里。
    def intersection(self, *args, **kwargs): # real signature unknown
        """
        Return the intersection of two sets as a new set.

        (i.e. all elements that are in both sets.)
        """
        pass

>>> s1 = {11,22,33,}
>>> s2 = {22,33,44,}
>>> s3 = s1.intersection(s2)
>>> print("%s \n%s \n%s" % (s1,s2,s3))
{33, 11, 22}
{33, 44, 22}
{33, 22}

# s1.intersection(s2) 找到即在集合s1中,又在集合s2中的元素,并把结果更新到s1中
    def intersection_update(self, *args, **kwargs): # real signature unknown
        """ Update a set with the intersection of itself and another. """
        pass

>>> s1 = {11,22,33,}
>>> s2 = {22,33,44,}
>>> s1.intersection_update(s2)
>>> print("%s \n%s" % (s1,s2))
{33, 22}
{33, 44, 22}

  # 判断两个集合是否有交接,没有交集时返回True,有交集时返回False

    def isdisjoint(self, *args, **kwargs): # real signature unknown
        """ Return True if two sets have a null intersection. """
        pass

>>> s1 = {11,22,33,}
>>> s2 = {22,33,44,}
>>> s3 = {1,2,3,}
>>> s1.isdisjoint(s2)
False
>>> s1.isdisjoint(s3)
True

# s1.issubset(s2) 判断s1是不是s2的子集

    def issubset(self, *args, **kwargs): # real signature unknown
        """ Report whether another set contains this set. """
        pass

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

# s1.issuperset(s2) 判断s1是不是s2的父集
    def issuperset(self, *args, **kwargs): # real signature unknown
        """ Report whether this set contains another set. """
        pass

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


# 任意删除并返回一个元素
    def pop(self, *args, **kwargs): # real signature unknown
        """
        Remove and return an arbitrary set element.
        Raises KeyError if the set is empty.
        """
        pass

>>> s1 = {11,22,33,44,55,}
>>> s1.pop()
33

    # 删除指定的一个元素,这个元素必须在集合中,否则报错。区别于discard()
    def remove(self, *args, **kwargs): # real signature unknown
        """
        Remove an element from a set; it must be a member.

        If the element is not a member, raise a KeyError.
        """
        pass

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

    # 删除指定的一个元素,如果元素不存在不报错。可以起到判断元素是否在集合中时,代码不报错的作用。
    def discard(self, *args, **kwargs): # real signature unknown
        """
        Remove an element from a set if it is a member.

        If the element is not a member, do nothing.
        """
        pass

>>> s1 = {11,22,33,}
>>> s1.discard(11)
>>> print(s1)
{33, 22}
>>> s1.discard(44)   # 44 不在s1中,操作时不报错
>>> print(s1)
{33, 22}

# 相当于取两个集合的并集,再把他俩的交集删掉。返回这个新集合。
    def symmetric_difference(self, *args, **kwargs): # real signature unknown
        """
        Return the symmetric difference of two sets as a new set.

        (i.e. all elements that are in exactly one of the sets.)
        """
        pass

>>> s1 = {11,22,33,44,}
>>> s2 = {22,44,55,66}
>>> s3 = s1.symmetric_difference(s2)
>>> print("%s \n%s \n%s" % (s1,s2,s3))
{33, 11, 44, 22}
{66, 44, 22, 55}
{33, 66, 11, 55}

    # s1.symmetric_difference_update(s2) 相当于取s1,s2两个集合的并集,再把他俩的交集删掉。结果赋值给s1
    def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
        """ Update a set with the symmetric difference of itself and another. """
        pass

>>> s1 = {11,22,33,44,}
>>> s2 = {22,44,55,66}
>>> s1.symmetric_difference_update(s2)
>>> print("%s \n%s" % (s1,s2))
{33, 66, 11, 55}
{66, 44, 22, 55}

    # 取两个集合的并集,结果返回到一个新集合中。
    def union(self, *args, **kwargs): # real signature unknown
        """
        Return the union of sets as a new set.

        (i.e. all elements that are in either set.)
        """
        pass

>>> s1 = {11,22,33,44,}
>>> s2 = {22,44,55,66}
>>> s3 = s1.union(s2)
>>> print("%s \n%s \n%s" % (s1,s2,s3))
{33, 11, 44, 22}
{66, 44, 22, 55}
{33, 66, 11, 44, 22, 55}

# s1.update(s2) 去两个集合的并集,将结果赋值给s1
    def update(self, *args, **kwargs): # real signature unknown
        """ Update a set with the union of itself and others. """
        pass

>>> s1 = {11,22,33,44,}
>>> s2 = {22,44,55,66}
>>> s1.update(s2)
>>> print("%s \n%s" % (s1,s2))
{33, 66, 11, 44, 22, 55}
{66, 44, 22, 55}


二、函数

为什么要创建函数?

提升代码的复用性和可读性

# 使用函数前,是面向过程变成,更具逻辑从上到下一行一行执行。
while True:
    if cpu利用率 > 90%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接

    if 硬盘使用空间 > 90%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接

    if 内存占用 > 80%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接

sendmail函数(使用参数前)

# 使用函数后,就变成函数式,面向对象编程
def 发送邮件(内容)
    #发送邮件提醒
    连接邮箱服务器
    发送邮件
    关闭连接

while True:

    if cpu利用率 > 90%:
        发送邮件(‘CPU报警‘)

    if 硬盘使用空间 > 90%:
        发送邮件(‘硬盘报警‘)

    if 内存占用 > 80%:
        发送邮件(‘内存报警‘)
 

sendmail函数(使用参数后)

函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可

面向对象:对函数进行分类和封装

1、函数的定义

def 函数名(参数):

    函数体

return

a、def——python中表示函数的关键字

b、函数名——定义函数名称,以后根据函数名称来调用函数

c、(参数)——为函数提供数据

d、函数体——定义在函数中的一系列逻辑计算,函数具体功能的代码实现,写在这个里面

e、返回值(return)——当函数执行完毕后,给调用者返回数据

示例1:邮件发送函数

def sendmail():
    import smtplib
    from email.mime.text import MIMEText
    from email.utils import formataddr

    msg = MIMEText(‘邮件内容‘, ‘plain‘, ‘utf-8‘)
    msg[‘From‘] = formataddr(["武沛齐", ‘[email protected]‘])
    msg[‘To‘] = formataddr(["走人", ‘[email protected]‘])
    msg[‘Subject‘] = "主题"

    server = smtplib.SMTP("smtp.126.com", 25)
    server.login("[email protected]", "WW.3945.5")
    server.sendmail(‘[email protected]‘, [‘[email protected]‘, ], msg.as_string())
    server.quit()
sendmail()

sendmail()——无参数

2、参数的使用

示例1中,实现了给[email protected]发用邮件的功能。但是如果我想要给不同的收件人发邮件,就要写好多个函数,起不到复用代码的效果。因此加上参数。

def sendmail(user_email):  # user_email 叫做函数sendmail的形式参数,简称形参
    import smtplib
    from email.mime.text import MIMEText
    from email.utils import formataddr

    msg = MIMEText(‘邮件内容‘, ‘plain‘, ‘utf-8‘)
    msg[‘From‘] = formataddr(["武沛齐", ‘[email protected]‘])
    msg[‘To‘] = formataddr(["走人", ‘[email protected]‘])
    msg[‘Subject‘] = "主题"

    server = smtplib.SMTP("smtp.126.com", 25)
    server.login("[email protected]", "WW.3945.5")
    server.sendmail(‘[email protected]‘, [user_email, ], msg.as_string())
    server.quit()
sendmail("[email protected]”)  # [email protected]叫做sendmail的实际参数,调用sendmail函数时把这个参数传递给函数来执行。叫做实际参数,简称实参
sendmail(“[email protected]")
sendmail(“[email protected]")

sendmail(user_email)——有参数

引入参数后,就可以给上面三个邮箱发送邮件,而不用定义多个函数。

3、多个参数的使用和返回值

示例2:登陆、注册函数

def login(username, password):
    """
    用于用户登陆
    :param username: 用户输入的用户名
    :param password: 用户输入的密码
    :return: True,登陆成功;False,登录失败
    """
    with open("db", "r") as f:
        for i in f:
            user_pwd_list = i.strip().split(",")
            if username == user_pwd_list[0] and password == user_pwd_list[1]:
                return True
    return False

def register(username, password):
    """
     用于用户注册
    :param username: 用户输入的用户名
    :param password:  用户输入的密码
    :return: None
    """
    item = "\n{username},{password}".format(username=username, password=password)
    with open("db", "a") as f:
        f.write(item)
    print("注册成功")

def main():
    """
    用于程序执行的入口
    :return:  默认返回None
    """
    choice = input("[1:登陆],[2:注册],请输入数字编号:")
    user = input("请输入用户名:")
    pwd = input("请输入密码:")
    if choice == "1":
        t = login(user, pwd)  # 函数的return返回值赋值给t
        if t is True:
            print("登陆成功")
        else:
            print("登陆失败")

    elif choice == "2":
        register(user, pwd)

main()

登陆注册

示例中定义了三个函数,login、register、main。前两个函数需要传递用户名和密码两个参数才能正常完成用户的登陆和验证。因此设定两个形参,让调用者传递两个实参来实现功能。而main函数中,函数的返回值赋值给了t,通过对t的值进行判断,实现了打印不同内容的功能。

4、函数参数的更多类型

上面两个示例都是对普通参数的使用,参数还有更多类型,下面一一说明。

# 普通参数
def send(email, user, msg):
    print(‘发送成功‘, email, user, msg)
    return True

res = send("[email protected]", "Pesen", "发送成功”)  # 传递实参时,要按照形参指定的顺序来填写,否则使用了错误的参数,程序很有可能会出现错误。
if res is True:
    print("发送成功")
else:
    print("发送失败")

# 默认参数(默认参数必须放到最后定义,否则会报错)
def send(email, user=“Pesen", msg="发送成功”):  # 给user、msg两个形参指定默认值
    print(‘发送成功‘, email, user, msg)
    return True

res = send("[email protected]”)  # 不给send函数传递user,msg的实参,会使用默认值
if res is True:
    print("发送成功")
else:
    print("发送失败")

# 指定参数:可以打破实参传递的顺序
def send2(email, user, msg):
    print("邮件信息:", email, user, msg)
send2(user="Pesen", msg="OK", email="[email protected]")

# 动态参数

时间: 05-21

Python学习之旅 —— 基础篇(三)set集合、函数、文件操作的相关文章

Python学习之旅 —— 基础篇(四)内置函数、装饰器

本篇要点: 内置函数 装饰器 一.内置函数 # abs() :取绝对值 >>> res = abs(-10) >>> print(res) 10 # 0,None,"",{},[],() 布尔值都为空 # all(),any() 判断值的真假 # all() 所有为真才为真 p = all([0,1,2,3]) # 0为False,所有p 是False print(p) # any() 任意一个为真即为真 p = any((0,""

Python学习之旅 —— 基础篇(五)字符串格式化、递归、生成器&amp;迭代器、模块

本篇要点:字符串格式化递归生成器和迭代器模块 一.字符串格式化 字符串格式化的两种方式:占位符 %, format函数1.占位符% %[(name)][flags][width].[precision]typecode - (name) 可选,用于选择指定的key - flags 可选,可供选择的值有: - + 右对齐:正数前加正好,负数前加负号: - - 左对齐:正数前无符号,负数前加负号: - 空格 右对齐:正数前加空格,负数前加负号: - 0 右对齐:正数前无符号,负数前加负号:用0填充空

Python学习之旅 —— 基础篇(八)面向对象

概述 面向过程:根据业务逻辑从上到下写垒代码 函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可 面向对象:对函数进行分类和封装,让开发“更快更好更强...” 对比示例:函数式变成和面向对象编程 连接数据库的增删改查 # 函数式编程 def slect(host, username, password, sql): pass def create(host, username, password, database): pass def remove(host, usernam

Python学习之旅 —— 基础篇(七)反射、冒泡排序算法

本篇要点: 冒泡算法 反射 一.冒泡排序 比较相邻的元素.如果第一个比第二个大,就交换他们两个. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.这步做完后,最后的元素会是最大的数. 针对所有的元素重复以上的步骤,除了最后一个. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较. 代码示例: li = [5, 67, 2, 8, 5, 19, 6, 33, 98, ] times = len(li) for i in range(times): for j in

python学习之路基础篇(第七篇)

一.模块 configparser XML shutil zipfile 和 tarfile subprocess 二.面向对象 什么是面向对象 self是什么鬼 构造方法 面向对象的三大特性:封装,继承,多态 已经学习过的python内置类:str  list  tuple dict  set python自定义类 python单继承 python多继承

python学习之路基础篇(第五篇)

前四天课程回顾 1.python简介 2.python基本数据类型 类: int:整型 | str:字符串 | list:列表 |tuple:元组 |dict:字典 | set:集合 对象: li = [11,22,33] #列表的一个对象 s = "MoHan" #字符串的一个对象 3.函数式编程 4.装饰器 @装饰器函数名 def func(): pass 其中@装饰器函数名,程序执行到此,会进行如下三步操作: 1.将func当做参数进行传递给装饰器函数并执行 2.将装饰器函数的返

Python学习之旅 —— socket篇(一)

一.什么是socket socket通常也称作"套接字",用于描述IP地址和端口,是一个通信链的句柄,应用程序通常通过"套接字"向网络发出请求或者应答网络请求. socket起源于Unix,而Unix/Linux基本哲学之一就是“一切皆文件”,对于文件用[打开][读写][关闭]模式来操作.socket就是该模式的一个实现,socket即是一种特殊的文件,一些socket函数就是对其进行的操作(读/写IO.打开.关闭) socket和file的区别: file模块是针

WCF学习之旅----基础篇之MSMQ

服务端 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Messaging; namespace BaseOfWcf {     class Program     {         static void Main(string[] args)         {             //if (!MessageQueue.Exists(@

python学习—-day1.计算机基础

python学习-day1.计算机基础 一.计算机系统的硬件组成部分:电脑的三大件:内存.硬盘.cpu 二.编程语言的作用及操作系统和硬件的关系:答:1.编程语言的作用是与计算机沟通,并且可以用编程语言在操作系统上写程序,从而达到开发应用软件的目的2.操作系统是用来管理计算机硬件资源的 三.应用程序->操作系统->硬件:在硬件之上装操作系统,在操作系统上装应用程序1.应用程序是指程序员开发的可运行的软件2.操作系统的目的是用来管理计算机硬件的3.硬件:cpu.硬盘.内存.键盘.鼠标统称为电脑硬