Python基础第三天

三元运算

三元运算又叫三目运算,是对简单的条件语句的缩写,例如if判断

# 标准if判断语法

if 1 == 1:
    name = "yes"
else:
    name = "no"

# 如果 1==1 成立,name = "yes", 否则 name = "no"

# 三元运算简写语法

name = "yes" if 1 == 1 else "no"

# 如果条件成立,将yes赋值给name变量,否则将no赋值给name变量

集合

set集合,是一个无序且不重复的元素集合

# 创建集合

s1 = {11,22}
s2 = set()
s3 = set([11,22,33,4])

# 操作集合

s = set()
s.add(123) # 把要传入的元素做为一个整个添加到集合中
s.update(123) # 把要传入的元素拆分,做为个体传入到集合中
s.clear() # 删除集合中所有元素

s1 = {11,22,33}
s2 = {22,33,44}
s3 = s1.difference(s2)  # s1中存在,s2中不存在
s3 = s2.difference(s1)  # s2中存在,s2中不存在
s3 = s1.symmetric_difference(s2) #s1 s2 中不同时存在的
s1.difference_update(s2) # 更新s1中存在,s2中不存在
s1.symmetric_difference_update(s2)  # 更新s1 s2 中不同时存在的
s1 = {11,22,33}
s1.discard(1111) # 如果1111是集合s1中的元素删除,不存在不报错
s1.remove(11111) #  如果1111是集合s1中的元素删除,不存在报错
ret = s1.pop() # 删除集合中任意一个对象,返回它
s3 = s1.union(s2) # 返回一个新集合,集合元素是s1 s2的并集
s3 = s1.intersection(s2)# 返回一个新集合,集合元素是s1 s2的交集
s1.intersection_update(s2) # s1中成员是共同属于s1和s2

# li = [11,22,33] # list __init__
# li()            # list __call__
# li[0]           # list __getitem__
# li[0] = 123     # list __setitem__
# def li[1]       # list __delitem__
old_dict = {
    "#1": 8,
    "#2": 4,
    "#4": 2,
}

new_dict = {
    "#1": 4,
    "#2": 4,
    "#3": 2,
}
# old_kyes = old_dict.keys()
# old_set = set(old_kyes)
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)

import re
re.match()   

函数

描述

在学习函数之前,一直遵循:面向过程编程,即:根据业务逻辑从上到下实现功能,其往往用一长段代码来实现指定功能,开发过程中最常见的操作就是粘贴复制,也就是将之前实现的代码块复制到现需功能处,函数式编程最重要的是增强代码的重用性和可读性

def sendmail():
    try:
        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()
    except:
        # 发送失败
        return "失败"
    else:
        # 发送成功
        return "cc"
ret = sendmail()

print(ret)
if ret == "cc":
    print(‘发送成功‘)
else:
    print("发送失败")

发邮件函数

定义和使用

def 函数名(参数):

    ...
    函数体
    ...
    返回值

格式

函数的定义主要有如下要点:

  • def:表示函数的关键字
  • 函数名:函数的名称,日后根据函数名调用函数
  • 函数体:函数中进行一系列的逻辑计算,如:发送邮件、计算出 [11,22,38,888,2]中的最大数等...
  • 参数:为函数体提供数据
  • 返回值:当函数执行完毕后,可以给调用者返回数据。

返回值

# 在函数中,一旦执行return,函数执行过程立即终止

def f1():
     print(123)
     return "111"
     print(456)

 r = f1()
 print(r)

 def f2():
     print(123)

 r = f2()
 print(r)

返回值

参数

函数中有不通的参数

  • 普通参数(严格按照顺序,将实际参数赋值给形式参数)

def sendmail(xxoo, content):
    # xxoo = alex
    try:
        import smtplib
        from email.mime.text import MIMEText
        from email.utils import formataddr
        msg = MIMEText(content, ‘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.59")
        server.sendmail(‘[email protected]‘, [xxoo,], msg.as_string())
        server.quit()
    except:
        # 发送失败
        return "失败"
    else:
        # 发送成功
        return "cc"

while True:
    em = input("请输入邮箱地址:")
    result = sendmail(em, "SB")
    if result == "cc":
        print("发送成功")
    else:
        print("发送失败")

形式参数

  • 默认参数(必须放置在参数列表的最后)

def send(xxoo, content, xx="OK"):
    print(xxoo, content, xx)
    print("发送邮件成功:", xxoo, content)
    return True

while True:
    em = input("请输入邮箱地址:")
    result = send(em, "SB", "ok")
    if result == True:
        print("发送成功")
    else:
        print("发送失败")

默认参数

  • 指定参数(将实际参数赋值给制定的形式参数)

def send(xxoo, content):
     print(xxoo, content)
     # print("发送邮件成功:", xxoo, content)
     return True

send(content="alex", xxoo="sb")

指定参数

  • 动态参数:

    * 默认将传入的参数,全部放置在元组中, f1(*[1`1,22,33,44])

      ** 默认将传入的参数,全部放置在字典中 f1(**{"kl":"v1", "k2":"v2"})

f1(n1="alex", n2=18)
dic = {‘k1‘: "v1", "k2":"v2"}
f1(kk=dic)

dic = {‘k1‘: "v1", "k2":"v2"}
f1(**dic)

f1(11)
li = [11,22,"alex", "hhhh"]
f1(li, ‘12‘)
li = [11,22,"alex", "hhhh"]
f1(li)
f1(*li)
li = "alex"
f1(*li)

动态参数

  • 万能参数, *args,**kwargs

def f1(*args, **kwargs):
    print(args)
    print(kwargs)

f1(k1="v1")

def f1(*args):
    # args = (11,)
    # args = ([11,22,"alex", "hhhh"],"12")
    print(args, type(args))

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

def f1(**args):
    # args = (11,)
    # args = ([11,22,"alex", "hhhh"],"12")
    print(args, type(args))

万能参数

全局变量

  • 全局变量,所有作用域都可读
  • 对全局变量进行【重新赋值】,需要global
  • 特殊:列表字典,可修改,不可重新赋值

def f1():
    age = 18
    global NAME # 表示,name是全局变量
    # NAME = "123"

    print(age, NAME)

def f2():
    age = 19
    print(age, NAME)
f1()
f2()

全局变量

文件处理

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()

f = open(‘db‘,‘r‘)
data = f.read()
print(data,type(data))

f = open(‘db‘,‘rb‘)
data = f.read()
print(data,type(data))

f = open("db", ‘a‘)
f.write("李杰")
f.close()

f = open("db", ‘ab‘)
f.write(bytes("李杰", encoding="utf-8"))
f.close()
f = open("db", ‘r+‘, encoding="utf-8")
# f.fileno()
# 如果打开模式无 b,则read,按照字符读取
data = f.read(1)
# tell当前指针所在的位置(字节)
print(f.tell())
# 调整当前指着你的位置(字节)
f.seek(f.tell())
# 当前指针位置开始向覆盖
f.write("888")
f.close()

打开文件

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

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

操作文件

f.close()
with open(‘xb‘) as f:
    pass
with open(‘xb‘) as f:
    pass

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)

关闭文件

时间: 2024-10-10 12:57:56

Python基础第三天的相关文章

Python基础(三)

Python基础(三) 深浅拷贝 函数(全局与局部变量) 内置函数 文件处理 三元运算 lambda 表达式 递归(斐波那契数列) 冒泡排序 深浅拷贝 一.数字和字符串 对于 数字 和 字符串 而言,赋值.浅拷贝和深拷贝无意义,因为其永远指向同一个内存地址. import copy #定义变量   数字.字符串 n1 = 123 #n1 = 'nick' print(id(n1))   #赋值 n2 = n1 print(id(n2))   #浅拷贝 n3 = copy.copy(n1) pri

Python 基础语法(三)

Python 基础语法(三) --------------------------------------------接 Python 基础语法(二)-------------------------------------------- 七.面向对象编程 python支持面向对象编程:类和对象是面向对象编程的两个主要方面,类创建一个新的类型,对象是这个类的实例. 对象可以使用普通的属于对象的变量存储数据,属于对象或类的变量被称为域:对象也可以使用属于类的函数,这样的函数称为类的方法:域和方法可

Python基础篇(三)

元组是序列的一种,与列表的区别是,元组是不能修改的. 元组一般是用圆括号括起来进行定义,如下: >>> (1,2,3)[1:2]     (2,) 如果元组中只有一个元素,元组的表示有些奇怪,末尾需要加上一个逗号: >>> (1,2,3)[1:2]     (2,) >>> 3*(3)      9      >>> 3*(3,)      (3, 3, 3) tuple函数 tuple函数用于将任意类型的序列转换为元组: >&

Python基础第三篇

一.collections系列 Counter是对字典类型的补充,用于追踪值的出现次数,具备字典的所有功能 + 自己的功能 1.计数器Counter import collections a='abababsbsbhh' c=collections.Counter(a) #直接列出每个元素出现了几次,传入列表和元组也一样 print(c) #输出:Counter({'b': 5, 'a': 3, 'h': 2, 's': 2}) #most_common 列出Counter内的前几个 print

Python基础入门 (三)

一.set 特点: set是一个无序且不重复的元素集合访问速度快:天生解决元素重复问题 方法: 初始化 >>> s1 = set()>>> print(type(s1))<class 'set'> add() 增加元素 >>> s1.add('tom')>>> print(s1){'tom'} clear() 清空 >>> s1.clear()>>> print(s1)set() 差集

python 基础第三篇

一. 编码1. 最早的计算机编码是ASCII. 美国人创建的. 包含了英文字母(大写字母, 小写字母). 数字, 标点等特殊字符[email protected]#$%128个码位 2**7 在此基础上加了一位 2**88位. 1个字节(byte)2. GBK 国标码 16位. 2个字节(双字节字符)3. unicode 万国码 32位, 4个字节4. utf-8: 英文 8 bit 1个字节欧洲文字 16bit 2个字节中文 24bit 3个字节 8bit => 1 byte1024 byte

Python基础语法三组合数据类型

一.列表(Lists) 列表属于Python中的序列类型,它是任意对象的有序集合,通过 " 位置 "或者 " 索引 " 访问其中的元素,它具有可变对象.可变长度.异构和任意嵌套的特点. 列表里第一个元素的为值或者索引是从 " 0 " 开始,第二个元素则是 " 1 ",一次类推. 列表的元素放置在方括号 [] 中,以逗号来分隔各元素: 格式如下: listname = [元素1,元素2,元素3,...,元素n ] 1 1 lis

python基础(三)----字符编码以及文件处理

字符编码与文件处理 一.字符编码 由字符翻译成二进制数字的过程 字符--------(翻译过程)------->数字 这个过程实际就是一个字符如何对应一个特定数字的标准,这个标准称之为字符编码. 字符编码的发展史 阶段一:现代计算机起源于美国,最早诞生也是基于英文考虑的ASCII ASCII:一个Bytes代表一个字符(英文字符/键盘上的所有其他字符),1Bytes=8bit,8bit可以表示0-2**8-1种变化,即可以表示256个字符 ASCII最初只用了后七位,127个数字,已经完全能够代

Python之路【第三篇补充】:Python基础(三)

lambda表达式 学习条件运算时,对于简单的 if else 语句,可以使用三元运算来表示,即: # 普通条件语句 if 1 == 1: name = ‘luotianshuai' else: name = 'shuaige' # 三元运算 name = 'luotianshuai' if 1 == 1 else 'shuaige' #这个就是if else的一个简写. #if 条件成立的时候name为'luotianshuai' 不成立的时候为:'shuaige' ,语法糖! 那么函数有没有

第二章 python基础(三)

第十六节 MySQLdb win64位安装python-mysqldb1.2.5 ubuntu下安装MySQLdb sudo apt-get install python-MySQLdb 导入MySQLdb库 import MySQLdb 创建数据库连接 conn = MySQLdb.connect(host="localhost",user="root",passwd="123456",db="test",charset=&