python基础(三)

set集合

• set集合创建

#方式1：
se = {'',''} #与字典类似dict1 = {'k1','v1','k2','v2'}
#方式2：
se = set() #创建一个空的集合
list1 = [11,22,33,44]
se = set(list1)
print(se)

• 操作集合

s = set()
print(s)
s.add(123)    #添加集合元素
s.add(123)
s.add(123)  #体现集合不重复性，添加多个但是集合中只有一个123
print(s)
s.clear()    #clear方法是清空s集合元素
print(s)

set()
{123}
set()

#找不同
s1 = {11,22,33}
s2 = {22,33,44}
s3 = s1.difference(s2) #A中存在，B中不存在，例子中为存在s1中不存在s2中的集合
s4 = s2.difference(s1) #s2中存在s1中不存在的集合
s5 = s1.symmetric_difference(s2) #A中存在B中不存在并且B中存在A中不存在的集合
print(s1) #{11,22,33}
print(s2)  #{22,33,44}
print(s3) #{11}
print(s4) #{44}
print(s5) #{11, 44}

s1.difference_update(s2) #将s1中存在s2种不存在的元素更新覆盖到s1集合中
print(s1) #{11}
s1.symmetric_difference_update(s2) #将s1中存在s2中不存在并且s2中存在s1中不存在的元素更新追加到s1集合中
print(s1) #{33, 11, 44, 22}

#删除元素的几种方法
s1 = {11,22,33}
s1.discard(1111)#移除1111的元素，不存的元素不报错
s1.remove(11111)#不存在的元素报错
s1.pop() #随机删除元素
ret = s1.pop() #取随机移除的元素
print(s1)
print(ret)

#并集和交集
s1 = {11,22,33}
s2 = {22,33,44}
print(s1,s2) #{33, 11, 22} {33, 44, 22}
s3 = s1.union(s2) #取s1和s2的并集
print(s3) #{33, 22, 11, 44}
s4 = s1.intersection(s2) #s1和s2的交集
print(s4) #{33, 22}
s1.intersection_update(s2) #将s1和s2的交集结果写入覆盖到s1中
print(s1) #{33, 22}

#追加方法
s1 = {11,22,33}
s1.add(11) #add方法
s1.add(12)
s1.add(13)
#li = [11,22,3,11,2] #列表update进集合
#li = (11,22,3,11,2) #元组update进集合
#li = "alexalex" #字符串按照字符循环方式update到s1中
s1.update(li) #update方法
print(s1) #{33, 'e', 11, 12, 13, 'a', 'l', 'x', 22}

练习：

cmdb练习 #代表槽位，数字代表内存大小，由old状态变到new的状态

要删除哪些槽位

要更新哪些槽位

要增加哪些槽位

old_dic = {
    "#1":8,
    "#2":4,
    "#4":2,
}
new_dic = {
    "#1":4,
    "#2":4,
    "#3":2,
}

具体操作过程

new_set = set(new_dict.keys())
old_set = set(old_dict.keys())

remove_set = old_set.difference(new_set) #删除的槽位
add_set = new_set.difference(old_set) #增加的槽位
update_set = old_set.intersection(new_set) #更新的槽位

函数

1. def关键字创建函数
2. 函数名+()
3. 函数体
4. 返回值return  #在函数中一旦出现return函数执行过程立即中止，默认return值为none
5. 参数
   • 普通参数（严格按照顺序，将实际参数赋值给形式参数）
   • 指定参数（必须放置在参数列表的最后）
   • 默认参数（将实际参数赋值给制定的形式参数）
   • 动态参数
     • * 默认将传入的参数，全部放置在元组中， f1(*[1`1,22,33,44])
     • ** 默认将传入的参数，全部放置在字典中   f1(**{"kl":"v1", "k2":"v2"})
   • 万能参数 *args,**kwargs
6. 补充
   • 程序中定义两个相同的函数名时，程序会执行最下面的函数体
   • 引用
   • 全局变量
     • 全局变量,所有的作用域都可读，全局变量重新赋值需要global关键字
     • 特殊列表字典可修改不可重新赋值
     • 全局和局部变量都存在时，优先匹配局部的(函数内和函数外均有同一个变量时优先匹配函数体内自己的变量)
     • global +变量名 #表示变量为全局变量,全局变量赋值一律都用大写
7. 内置函数

发送邮件练习

#!/usr/bin/env python
# -*- codind:utf-8 -*-
#Author:ljb
def sendmail():

    try:
        import smtplib
        from email.mime.text import MIMEText
        from email.utils import formataddr

        msg = MIMEText('邮件内容', 'plain', 'utf-8')
        msg['From'] = formataddr(["郎建彬",'ljb880903@163.com'])
        msg['To'] = formataddr(["走人",'1037258416@qq.com'])
        msg['Subject'] = "主题"

        server = smtplib.SMTP("smtp.163.com", 25)
        server.login("ljb880903@163.com", "密码")
        server.sendmail('ljb880903@163.com', ['1037258416@qq.com',], msg.as_string())
        server.quit()
    except:
        return  '失败'
    else:
        return 'cc'
sendmail()
ret = sendmail()
print(ret)
if ret == 'cc':
    print('发送成功')
else:
    print('发送失败')

参数练习

def send(addr,content,stat='ok'):#形式参数，stat=ok 为默认参数
    print('发送%s的内容%s结果为%s'% (addr,content,stat))
    return 'ok'

ret = send('ljb','test') #默认参数，实际参数，ljb和test为传过来的普通参数
ret = send('ljb','test','fail')
ret = send(content='ljb',addr='test') #指定参数

if ret == 'ok':
    print('发送成功')
else:
    print('发送失败')

动态参数*练习

def f1(*args):
    print(args)

li = [11,22,'ljb','test',]
f1(11,22,33,44)
f1(li,12)
f1(*li)
'''
(11, 22, 33, 44)    #以元组方式打印出来
([11, 22, 'ljb', 'test'], 12)   #传人列表的话将列表作为一个元素写入元组
(11, 22, 'ljb', 'test')
'''

万能参数练习

#万能参数
print('万能参数')
def f1(*args,**kwargs):
    print(args)
    print(kwargs)
f1(11,22,33,44,k1='v2',k2='v2')
print('**参数')
def f2(**args):
    print(args,type(args))
f2(n1 = 'ljb',n2=18)
dict = {'k1':'v1','k2':'v2'}
f2(k2=dict)
f2(**dict)

万能参数
(11, 22, 33, 44)
{'k1': 'v2', 'k2': 'v2'}
**参数
{'n1': 'ljb', 'n2': 18} <class 'dict'>
{'k2': {'k1': 'v1', 'k2': 'v2'}} <class 'dict'>
{'k1': 'v1', 'k2': 'v2'} <class 'dict'>

动态参数和万能参数的应用

str.format()格式化输出

s1 = 'I am {0},age {1}'.format('ljb',23)

print(s1)
s2 = 'I am {0},age {1}'.format(*['ljb',23])
print(s2)

s3 = 'I am {name},age {age}'.format(name = 'ljb',age = 23)
print(s3)
dic1 = {'name':'ljb','age':23}
s4 = 'I am {name},age {age}'.format(**dic1)
print(s4)

I am ljb,age 23
I am ljb,age 23
I am ljb,age 23
I am ljb,age 23

补充相同函数程序会执行最下面的函数体

#定义2个一样的def ，以后面的def名称为准了
def f1 (a1,a2):
    return  a1+a2
def f1 (a1,a2):
    return a1*a2
ret = f1(8,8)
print(ret)

64

补充引用列表练习

def f1(a1):
    a1.append(999) #这里引用的是li列表的地址，所以li也会append 999

li = [11,22,33,44]
f1(li)

print(li) #[11, 22, 33, 44, 999]

补充全局变量练习

#特殊列表字典可修改不可重新赋值
def f1 (a1):
    a1.append(999)
li = [11,22,33,44]
f1(li)
print(li)

[11, 22, 33, 44, 999]

#global +变量名 #表示变量为全局变量,全局变量赋值一律都用大写
NAME = 'ljb'
def f1():
    age = 18
    global NAME
    NAME = ''
    print(NAME,age)
def f2():
    age = 19
    print(NAME,age)
f1()
f2()
123 18
123 19

函数练习写登陆程序

#!/usr/bin/env python
# -*- codind:utf-8 -*-
#Author:ljb

def login(username,password):
    '''
    用于用户登录
    :param username:登陆用户名
    :param password:登陆密码
    :return:true 登陆成功，false登录失败
    '''
    f = open('db','r')
    for line in f:
        line_list = line.strip().split('|')
        if username == line_list[0] and password ==  line_list[1]:
            return True
    return False

def register(username,password):
    '''
    用于用户注册
    :param username:注册用户名
    :param password: 注册密码
    :return:none
    '''
    f = open('db','a')
    temp = '\n' + username + '|'+ password
    f.write(temp)
    f.close()
    return  True

def main():
    t = input("1 登陆 2 注册")
    if t == '':
        user = input('输入用户名：')
        passwd = input('输入密码：')
        r = login(user,passwd)
        if r :
            print('登陆成功')
        else:
            print('登陆失败')
    elif t == '':
        user = input('输入用户名：')
        passwd = input('输入密码：')
        r1 = register(user,passwd)
        if r1 :
            print('注册成功')
        else:
            print('注册失败')

main()

内置函数练习

n = abs(-1) #取绝对值
a1 = all([0,1,2,3]) #all中参数必须为可迭代的变量，0，None,"",[],()为False,1为True,可迭代的变量中全部为真才为真，返回True否则返回False
a2 = any([0,1,2,3]) #any与all相反，可迭代的变量中有一个元素为真就为真返回True，否则返回False,有真即为真
a3 = any([0,[],None,"",()])
print(n) #
print(a1) #False
print(a2) #True
print(a3) #False

#ascii() #自动执行对象 __repr__
class Foo:
    def __repr__(self):
        return ""

a4 = ascii(Foo())
print(a4)

#进制转换bin，oct，hex参数均为int类似整数
a1 = bin(5) #输入数字转化二进制0b开头
a2 = oct(9) #输入数字转化八进制0o开头
a3 = hex(15) #输入数字转化十六进制 0x开头
print(a1) #0b101
print(a2) #0o11
print(a3) #0xf

# 字符串转换字节类型
#位，字节，汉字的关系
# 1、bit：位
#     一个二进制数据0或1是1bit
# 2、byte：字节
#     存储空间的基本计量单位 如：MySQL中定义 VARCHAR(45)  即是指 45个字节
#     1byte = 8bit
# 3、一个英文字符占用1个字节
#     1字母 = 1byte = 8bit
# 4、一个汉字占用2个字节(GBK中)
# 5、标点符号
#      汉字输入状态下，默认为全角输入方式；
#      英文输入状态下，默认为半角输入方式；
#      全角输入方式下，标点符号占2字节；
#      半角输入方式下，标点符号占1字节；

# utf-8 一个汉字：三个字节
# gbk 一个汉字：二个字节
# utf-8
s = "李杰"
# 一个字节8位，一个汉字三个字节
# 字符串转换字节类型
# bytes(要转换的字符串，编码形式）
n = bytes("李杰", encoding="utf-8")
print(n) #b'\xe6\x9d\x8e\xe6\x9d\xb0' utf-8一个汉字占用3个字节
n = bytes("李杰", encoding="gbk")
print(n) #b'\xc0\xee\xbd\xdc' GBK一个汉字占用2个字节
# 字节转化成字符串
new_str = str(bytes("李杰", encoding="utf-8"), encoding="utf-8")
print(new_str)

#列表调用内部函数
li = [11,22,33,44] #list __init__
li()                        #list __call__
li[0]                     #list __getitem__
li[0]                     #list __setitem__
def li[1]               #list __delitem__

python encode和decode函数说明

字符串转为字节类型，

str='ssssss'

s1_byte = str.encode()

字节转换为字符串类型

s1_str = s1_byte.decode()

文件

• 打开文件

• 打开文件的模式有：

  • r ，只读模式【默认】
  • w，只写模式【不可读；不存在则创建；存在则清空内容；】
  • x， 只写模式【不可读；不存在则创建，存在则报错】
  • a， 追加模式【可读；   不存在则创建；存在则只追加内容；】

  "+" 表示可以同时读写某个文件

  • r+， 读写【可读，可写】
  • w+，写读【可读，可写】
  • x+ ，写读【可读，可写】
  • a+， 写读【可读，可写】

  "b"表示以字节的方式操作

  • rb  或 r+b
  • wb 或 w+b
  • xb 或 w+b
  • ab 或 a+b

  注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型

# f = open('db', 'r') # 只读
# f = open('db', 'w') # 只写，先清空原文件
# f = open('db', 'x') # 文件存在，报错；不存在，创建并只写
# f = open('db', 'a') # 追加
# f = open('db','r', encoding="utf-8")
# data = f.read()
# print(data, type(data))
# f.close()

# #是否以加b方式打开区别，rb方式以二进制只读方式打开
# f = open('db','r')
# data = f.read()
# print(data,type(data))  #ljb 1234
#                         #lang 1234 <class 'str'>
#
# f = open('db','rb')
# data = f.read()
# print(data,type(data)) #b'ljb 1234\r\nlang 1234' <class 'bytes'>

#带b和不带b方式追加写入文件区别
# f = open("db", 'a')
# f.write("李杰")     #不带b方式直接写入字符串即可
# f.close()
#
# f = open("db", 'ab')
# f.write(bytes("李杰", encoding="utf-8")) #带b方式需要将写入的字符串转化为字节
# f.close()

f = open("db", 'r+', encoding="utf-8")
#f.fileno() #此方法返回整数的底层实现使用请求从操作系统的I / O操作的文件描述符
# 如果打开模式无 b，则read，按照字符读取
data = f.read(5) #从头开始读取5个字符
print(data)
# tell当前指针所在的位置（字节）
print(f.tell())
# 调整当前指着你的位置（字节）
f.seek(f.tell())
# 当前指针位置开始向覆盖
f.write("")
f.close()

• 操作文件

# read() # 无参数，读全部；有参数，
#                                    b，按字节
#                                    无b，按字符
# tell() 获取当前指针位置(字节)
# seek(1) 指针跳转到指定位置(字节)
# write（） 写数据，b，字节；无b，字符
# close
# fileno
# flush 强刷
# readline 仅读取一行
# truncate 截断，指针为后的清空
# for循环文件对象
# f = open('db','r+')
# for line in f:
#     print(line) #按行打印db中文件

#truncate 练习
f = open("db", 'r+', encoding="utf-8")
for line in f:
    print(line)
f.seek(3)
f.truncate()
f.close()
f = open("db", 'r+', encoding="utf-8")
for line in f:
    print(line)
f.close()

• 关闭文件

# 3、关闭文件(close和with两种方式)
# f.close()
# with open('xb') as f:
#     pass
with open('xb') as f:
    pass

#将f1中匹配xx的写入到f2中，line.replace为替换函数
with open('db1', 'r', encoding="utf-8") as f1, open("db2", 'w',encoding="utf-8") as f2:
    for line in f1:
        if line == "xx":
            f2.write()
            f2.write()
        # new_str = line.replace("alex", 'st')
        # f2.write(new_str)

#flush()练习，强制刷新写入磁盘
# f = open("db", 'a',encoding="utf-8")
# f.write("123")
# f.flush()
# input("asdfasd")

三元运算，三目运算

# 三元运算，三目运算，if else简写
"""
if 1 == 1:
    name = "alex"
else:
    name = "SB"
# 如果 1==1 成立，
# name = "alex"
# 否则
# name = "SB"
name = "alex" if 1 == 1 else "SB"
"""

def f1(a1):
    return a1 + 100

f2 = lambda a1, a2=9: a1 + a2 + 100

ret = f1(10)
print(ret)

r2 = f2(9)
print(r2)

学习条件运算时，对于简单的 if else 语句，可以使用三元运算来表示，即：

# 普通条件语句
if 1 == 1:
    name = 'jabe'
else:
    name = 'ljb'

# 三元运算
name = 'jabe' if 1 == 1 else 'ljb'
对于简单的函数，也存在一种简便的表示方式，即：lambda表达式

# ###################### 普通函数 ######################
# 定义函数（普通方式）
def func(arg):
    return arg + 1

# 执行函数
result = func(123)

# ###################### lambda ######################

# 定义函数（lambda表达式）
my_lambda = lambda arg : arg + 1

# 执行函数
result = my_lambda(123)
lambda存在意义就是对简单函数的简洁表示