python学习-day3

今天是第三天学习，加油！

 

第一部分 集合

一、集合

1.什么是集合以及特性？

特性：无序的，不重复的序列，可嵌套。

2.创建集合

方法一：创建空集合

s1 = set()
print(type(s1))

结果： 可以看出来创建的是集合类型的。

 

方法二：

s1 = {"123","456"}
print(s1)
print(type(s1))

结果：

 

方法三：列表转换为集合

list1 = [11,22,11,22]
s1 = set(list1)
print(s1)

结果：从结果可以看出来集合的特性：无序和不重复的特点

 

方法四：把字典转换为集合

1.把字典的key转换为集合

dict1 = {
    "key1":11,
    "key2":22,
    "key3":33,
}
set_dict1 = set(dict1)
print(set_dict1)

结果：

从结果可以看出来，默认是把字典的key转换为集合了。

 

2.把字典的key转换为集合

set(dict1.keys())

dict1 = {
    "key1":11,
    "key2":22,
    "key3":33,
}
set_dict1 = set(dict1.keys())
print(set_dict1)

结果：

从结果可以看出来，使用dict1.keys() 和set结合，也可以把字典的key转换为集合。

 

3.把字典的value值转换为集合

set(dict1.values())

 

dict1 = {
    "key1":11,
    "key2":22,
    "key3":33,
}
set_dict1 = set(dict1.values())
print(set_dict1)

结果：

从结果可以得出，使用dict1.values和set集合，可以把字典的value值转换为集合。

所以从以上关于字典的3个例子中可以得出结论：

结论：

1.字典转换为集合时，使用set（dict1()） 默认是把字典的key转换为集合；

2.使用  set(dict1.keys())   ，也可以把字典的key转换为集合；

3.使用set(dict1.values()) ，可以把字典的value转换为集合；

 

二、集合的操作

1.集合添加元素

add()
一次只能添加一个元素

s1 = set()
s1.add(123)
print(s1)

结果：

 1.1 看看这个例子

s1 = set()
s1.add(123)
s1.add(123)
s1.add(123)

print(s1)

结果：

为什么两个例子的结果完全一样？ why？

这两个例子的结果完全体现出了集合的特性：不重复！所以第二个例子虽然执行了3次 s1.add(123)  ，但是结果只有一个 {123}

 

2.集合批量添加元素（迭代添加）

update()

s1 = set()
list1 = [11,22,33,44]   #update接受一个可以被迭代的对象，也就是可以被for循环的。update相当于调用多次add函数
s1.update(list1)
print(s1)

结果：

 

 3.集合A中存在，集合B中不存在

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

结果：

{11}

4.集合的对称差集

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

结果：

{11, 44}

5.difference_update 的使用，这样就不用定义第三个变量了。

 

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

结果：

{11}

6. s1.symmetric_difference_update()使用和difference_update类似

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

结果：

{11, 44}

7.集合元素的移除

方法一：discard()

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

结果：

{33, 22}

方法二：

remove()

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

结果：

{33, 22}

 

对比：discard() 与 remove()的区别

s1.discard(1111)  #移除的不存在元素不会报错,最常用

s1.remove(1111)  #移除的值不存在的元素 会报错


方法三：
随机移除一个元素

s1 = {11,22,33}
ret = s1.pop()   #随机移除一个元素，并打印被移除的元素
print(ret)

 

8.集合的交集

intersection() 与 intersection_update()

s1 = {11,22,33}
s2 = {22,33,44}

s3 = s1.intersection(s2)
print(s3)
s1.intersection_update(s2)
print(s1)

结果：

{33, 22}
{33, 22}

9.集合并集

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

print(s3)

结果：

{33, 22, 11, 44}

 

第二部分：函数

一、函数的定义

1.什么是函数？

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

2.为什么要使用函数？

以前我们写的python或者bash 脚本都是面向过程的。即：根据业务逻辑从上到下实现功能，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，也就是将之前实现的代码块复制到现需功能处。

这样的缺点很明显，代码重复性高，可读性差等等。

3.函数的定义

定义函数，函数体不执行，只有调用函数时，函数体才执行

函数的定义规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

函数的几个名词解释：

• 函数名：函数的名称，日后根据函数名调用函数
• 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
• 参数：为函数体提供数据

 

 

语法：

def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]

默认情况下，参数值和参数名称是按函数声明中定义的的顺序匹配起来的。

 

二、函数的返回值：

1.默认返回值

def A():
    print(123)
    return   #不写return 返回的也是None

R = A()
print(R)

结果：可以看出来默认返回的是 None，不写return 也会返回None

2.指定返回值

def A():
    try:
        print(123)
    except:
        return False    #操作失败会执行except
    else:
        return True    #代码执行成功后，执行else：下的return

R = A()
print(R)

结果：

 

3.怎么利用返回值

一般我们使用函数的返回值去做一些判断操作

def A():
    try:
        print(123)
    except:
        return False    #操作失败会执行except
    else:
        return True    #代码执行成功后，执行else：下的return

R = A()
print(R)

if R == True:
    print("OK")
else:
    print("ERROR")

结果：

4.在函数中，一旦执行return，函数执行过程立即终止

def A():
    print(123)
    return 222  ##在函数中，一旦执行return，函数执行过程立即终止
    print(456)


R = A()
print(R)

结果：发现没有执行 print(456)命令

三、函数的执行顺序

python是从上到下的顺序执行，但是函数体的内容，只有调用函数时才会执行。

 

三、函数的参数：

1.普通参数：严格按照顺，将实际参数赋值给形式参数

2.默认参数：必须放置在参数列表的最后

3.指定参数：将实际参数赋值给指定的形式参数

4.动态参数：

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

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

5.万能参数：*args , **args

注意：

def send(user,content,xx):
    print(user,content,xx)

send("user1:","hello","ok")

结果：

 

2.默认参数：

注意：默认参数必须放在参数列表的最后面，例如下面的xx = "OK"  放到了参数列表的后面

def send(user,content,xx="OK"):
    print(user,content,xx)

send("user1:","hello","FFFF")
send("user1","hello")

结果：

从结果可以得出：xx = "OK" 就是默认参数，如果给xx指定了参数值，那么xx 就是指定的值。例如：上面指定了 FFFF

如果不指定参数值，那么xx就用默认的Ok值。例如：send("user1","hello") 这个没有为xx指定参数值。

 

3.指定参数：

 

def send(user,content):
    print(user,content)

send(content="hello", user = "user1")

结果：

可以通过content="hello" 把hello赋值给content变量，可以通过user = "user1"，把user1赋值给user变量，这就是指定变量。

 

4.动态参数*args

def f1(*args):
    print(args,type(args))
list1 = [11,22,"alex","hehe"]
f1(list1,'name')

结果：

由结果可以知道，我们传的参数，都会作为元组的一个元素，例如：列表list1=[11,22,'alex','hehe']  ，list1作为了 元组的一个元素，参数name也作为了元组的一个参数。

 

def f1(*args):
    print(args)
list1 = [11,22,"alex","hehe"]
f1(list1)  #把整个列表内容当成一个整体作为元祖的一个元素

结果：

从结果可以知道，把参数list1（列表），当成了一个整体作为元组的一个元素

 

def f1(*args):
    print(args)
list1 = [11,22,"alex","hehe"]
f1(*list1)  # 把列表中的每个值，分别作为元祖的每个元素

结果：

从结果可以知道：这个例子中，把参数list1（列表）的每个元素，分别作为元组的每一个元素来处理

 

5.动态参数 **args

5.1 使用key=value的形式传送变量和值

def f1(**args):
    print(args,type(args))
f1(n1="test",n2=30)

结果：

**args 参数是把传送过的值当作字典。

 

5.2 传的字典参数，还是按照字典来处理

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

dict1 = {'k1':"v1",'k2':"v2"}
f1(**dict1)

结果：

从结果可以知道，把字典的值传给**args后，也是按照字典的形式处理。

5.3 把整个字典作为value处理

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

dict1 = {'k1':"v1",'k2':"v2"}
f1(kk=dict1)

结果：

从结果可以看出来：kk是整个字典的key，而dict1作为一个整体成为kk的value值；

 

6.万能参数：

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

f1(11,22,33,44,k1="v1",k2="v2")

结果：

从结果可以得到：*args 是按照元组来处理。**args 是按照字典来处理的。

11,22,33,44 传给*args 处理。 k1="v1",k2="v2" 传给**args来处理。

 

 

四、全局变量

1.全部变量特性：

• 全局变量必须使用大写（这是python开发者的潜规则）
• 全局变量，所有作用域都可读
• 对全局变量进行【重新赋值】，需要global
• 特殊：列表字典，可修改，但是不可以重新赋值

2.对全局变量进行【重新赋值】，需要使用global

NAME = "test"

def f1():
    age = 18
    global NAME #表示，NAME是全局变量。
    NAME = "123"
    print(age,NAME)
def f2():
    age = 19
    print(age,NAME)
f1()
f2()

结果：全局变量NAME的值test 被修改为123

3.特殊：列表字典，可修改，但是不可以重新赋值

NAME = [11,22,33,44]
def f1():
    NAME.append(9999)  #可以修改
    print(NAME)

f1()

结果：列表NAME中已经增加了元素 9999

第三部分 字符串与字节的互相转换

# utf-8 一个汉字：三个字节

# gbk 一个汉字：二个字节

1.字符串转换为字节

格式

 bytes(要转换的字符串， 按照什么编码）

s = "百度"
n = bytes(s,encoding="utf-8")
print(n)

结果：

可以看到，一个汉字在utf-8类型中是占用3个字节

下面看下载gdk编码中：

s = "百度"
n = bytes(s,encoding="gbk")
print(n)

结果：

可以看出，在gbk编码中，一个汉字占2个字节

2.字节转换为字符串

使用str()

new_str = str(bytes("百度",encoding="utf-8"),encoding="utf-8")
print(new_str)

结果：

百度

 http://i.cnblogs.com/EditPosts.aspx?postid=5516664

第四部分  文件操作

 一、打开文件

语法：

文件句柄 = open('文件路径','模式')

打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。

f = open('db','r')  #只读模式【默认】
f = open('db','w')  #只写模式【不可读；不存在则创建；存在则清空内容；】
f = open('db','x')  #只写模式 【不可读；不存在则创建，存在则报错】
f = open('db','a')  #追加模式 【可读；不存在则创建；存在则只追加内容】
f = open('db','r',encoding="utf-8")

以上只是以字符串来进行操作。

如果使用 “b” 参数，表示以字节来操作，例如 wb,rb,ab  ，都是以字节为单位来操作的。

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

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

“b” 表示以字节的方式操作

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

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

read() 方法读取文件内容：

无参数，读全部；

如果打开模式无b，则read，按照字符读取。如果有b，则按照字节读取

2.seek()调整当前指针的位置（字节）

seek() 永远是以字节的形式移动位置。不管我们是以什么样的形式打开文件，都是以字节的形式移动位置。

 

3.tell()获取当前指针的位置（字节）

以字节的形式获取位置

例如：

文件db的内容为：

国admin 123456

f = open("db",'r+',encoding="utf-8")
#如果打开模式无b，则read，按照字符读取
data = f.read(1)
print(f.tell())
f.close()

结果：

3

因为在utf-8编码中一个汉字是3个字节。所以这里的结果是3

4.flush() 强制把内容写入到硬盘

5.readline() 仅读取一行

 

6.for循环文件对象（迭代文件内容）

f = open("db",'r+',encoding="utf-8")
for line in f:
    print(line)

 

7.with open('file1')  as file1 , open('file2')  as  f2:

把file1文件中的前10行，写入一个新文件file2里

with open('file1','r',encoding="utf-8") as f1,open('file2','w',encoding="utf-8") as f2:
    times = 0
    for line in f1:
        times += 1
        if times < 10:
            f2.write(line)
        else:
            break

8.把file1文件中的某个字符串替换为别的字符串，并生成一个新文件file2

下面的例子中，把关键字 baidu  替换为 google

with open('file1','r',encoding="utf-8") as f1,open('file2','w',encoding="utf-8") as f2:
    for line in f1:
        new_str = line.replace("baidu",'google')
        f2.write(new_str)

 

转载于:https://www.cnblogs.com/pangguoping/p/5516664.html