Python13_day3

http://www.cnblogs.com/wupeiqi/articles/4950799.html``

学习流程

一、基本的学习方法


1，看视频，听懂老师的课程。

2，下课做笔记，将笔记的内容写入到博客中，用自己的方式来写。

3，会看本周笔记内容，写相关的作业提交老师修改。继续学习上一周的内容。


set数据类型

二、set类型

   set数据类型：s ={11,22,33}

特点：元素无序且唯一。可以存放各种数据类型。


1，构建方法

1
2
3
4
5
6
# 方法一:
name = {12, 121, "alex", [1, 2, 3], {"name": "smith san"}, }
# 方法二：
name = set()
li = [2, 23, 4]
name = set(li)


2，操作

  • list_init_ 任何类的init的方法，都会执行内置的for循环，去初始化类。对于不同类型的数据可以做数据转换。

    1
    2
    3
    4
    5
    6
    7
    li = [11,22,11,22]
    UserDict = {"usernamer":"alex","password":9999}
    s1 = set(li)
    s2 = set(UserDict)
    print(s1,s2)
     
    {11, 22} {'usernamer', 'password'}


  • set.add()：添加一个元素进入集合，有就不添加，没有就添加

  • set.clear()：清空集合。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    s = set()
    print(s)
    s.add(234)
    s.add(123)
    s.add(123)
    print(s)
    s.clear()
    print(s)
     
    ---------
    set()
    {234, 123}
    set()


  • s1.difference(s2)：求s1中存在，s2中不存在的元素。

    s3 = s1.symmetric_difference(s2)：求s1和s2并集-s1和s2的交集。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
s1 = {11,22,33}
s2 = {22,33,44}
s3 = s1.difference(s2)
# s1中存在，s2中不存在
print(s3)
s3 = s2.difference(s1)
s3 = s1.symmetric_difference(s2)
print(s1)
print(s2)
print(s3)
--------
{11}
{33, 11, 22}
{33, 44, 22}
{11, 44}


  • s1.difference_update(s2)：用s1中有的s2中没有的元素更新s1

  • s1.symmetric_difference_update(s2):用s1中有的s2中没有的元素和s2中有的s1中没有的元素更新s1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
s1 = {11,22,33}
s2 = {22,33,44}
s1.difference_update(s2)
print(s1)
print(s2)
-----
{11}
{33, 44, 22}
 
 
s1 = {11,22,33}
s2 = {22,33,44}
s1.symmetric_difference_update(s2)
print(s1)
print(s2)
-----
{11, 44}
{33, 44, 22}


  • s1.discard(1111)  #被移除元素不存在不报错 常用

    s1.remove(11111)  #被移除元素不存在报错

    ret = s1.pop() #随机移除，ret接受移除的元素

    1
    2
    3
    4
    5
    6
    s1 = {11,22,33}
    s1.discard(1111)  #被移除元素不存在不报错 常用
    s1.remove(11111)  #被移除元素不存在报错
    ret = s1.pop() #随机移除，ret接受移除的元素
    print(s1)
    print(ret)
  • s3 = s1.union(s2)：s1和s2的并集
    s3 = s1.intersection(s2)：s1和s2 的交集
    s1.intersection_update(s2):s1的交集更新s1
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    s1 = {11,22,33}
    s2 = {22,33,44}
    s3 = s1.union(s2)
    print(s3)
    s3 = s1.intersection(s2)
    s1.intersection_update(s2)
    print(s3)
    print(s1)
    ------
    {33, 22, 11, 44}
    {33, 22}
    {33, 22}


  • s1.update(li):可以更新一个可迭代的东西进去，比如下面的list，tuple，string等。

  • 1
    2
    3
    4
    5
    6
    7
    8
    s1 = {11,22,33}
    #li = [11,22,3,11,2]
    #li = (11,22,3,11,2)
    li = "alexalex"
    s1.update(li)
    print(s1)
    -----
    {33, 11, 'l', 22, 'e', 'a', 'x'}

    类的自己的方法，python内部个调用一下方法。

    1
    2
    3
    4
    5
    # li = [11,22,33] # list __init__
    # li()            # list __call__
    # li[0]           # list __getitem__
    # li[0] = 123     # list __setitem__
    # def li[1]       # list __delitem__




    3，趣味题目。

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    old_dict = {
        "#1": 8,
        "#2": 4,
        "#4": 2,
    }
     
    new_dict = {
        "#1": 4,
        "#2": 4,
        "#3": 2,
    }
    old_keys = old_dict.keys()
    old_set = set(old_keys)
    print(old_set)
    new_keys = new_dict.keys()
    new_set = set(new_keys)
    print(new_set)
    #应该删除的槽位
    remove_set = old_set.difference(new_set)
    #应该更新的槽位
    update_set = old_set.intersection(new_set)
    #应该增加的槽位
    add_set = new_set.difference(old_set)
    print(remove_set,add_set,update_set)
    --------
    {'#2', '#1', '#4'}
    {'#2', '#1', '#3'}
    {'#4'} {'#3'} {'#2', '#1'}

函数

一，函数的定义主要有如下要点：

  • def：表示函数的关键字

  • 函数名：函数的名称，日后根据函数名调用函数

  • 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...

  • 参数：为函数体提供数据

  • 返回值：当函数执行完毕后，可以给调用者返回数据。

以上要点中，比较重要有参数和返回值：

一，返回值

函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者

1
2
3
4
5
6
7
8
9
10
#返回值告诉调用者调用结果
def send(email,time):
    mail_to = email
    send = 'Bruce'
    if time >=0:
        return "发送成功"
    else:
        return "发送失败"
 
send("306183118@qq.com",3)

二，参数

  • 普通参数（严格按照顺序，将实际参数赋值给形式参数）

    1
    2
    3
    4
    5
    def send(email,time):
        print(email,time)
        return email
     
    ret = send(email = "30@qq.com",time ="1101")

    默认参数（必须放置在参数列表的最后，可以和其他参数同时使用）

    指定参数（将实际参数赋值给制定的形式参数,顺序可变）
    1
    2
    3
    4
    5
    6
    7
    8
    def func(name, age = 18):
         
        print "%s:%s" %(name,age)
     
    # 指定参数
    func('wupeiqi', 19)
    # 使用默认参数
    func('alex')

    动态参数

    1，默认将传入的参数，全部放置在元组中， f1(*[1`1,22,33,44])
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    def func(*args):
     
        print args
     
     
    # 执行方式一
    func(11,33,4,4454,5)
     
    # 执行方式二
    li = [11,2,2,3,3,4,54]
    func(*li)
     
    动态参数一
    2，默认将传入的参数，全部放置在字典中   f1(**{"kl":"v1", "k2":"v2"})
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    def func(**kwargs):
     
        print args
     
     
    # 执行方式一
    func(name＝'wupeiqi',age=18)
     
    # 执行方式二
    li = {'name':'wupeiqi', age:18, 'gender':'male'}
    func(**li)
     
    动态参数二
    3，万能参数,   *args,**kwargs
    1
    2
    3
    4
    def func(*args, **kwargs):
     
        print args
        print kwargs

    4，字符串的格式化输出

  • 普通的格式化

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    # 字符串的格式化输出
    # str.format()
    # str format格式化输出
    # "%s %d"
    s1 = "i am {0}, age {1}".format("Bruce", 18)
    print(s1)
    s2 = "i am {0}, age {1}".format(*["Bruce", 18])
    print(s2)
     
    -----
    i am Bruce, age 18
    i am Bruce, age 18

  • 使用两个**处理字典的格式化调用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    s1 = "i am {name}, age {age}".format(name='Bruce', age=23)
    print(s1)
     
    dic = {'name': 'Bruce', "age": 12}
    s2 = "i am {name}, age {age}".format(**dic)
    print(s2)
    ----
    i am Bruce, age 23
    i am Bruce, age 12


  • 函数化编程（注册登录）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # Author:Wuzhibin
    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 line_list[0] == username and line_list[1] == password:
                return True
            else:
                return False
      
        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()
      
    def main():
        t = input("1 = login other = register :")
        if t =="1":
            user = input("Please input username:")
            pwd = input("Please input password:")
            r = login(user,pwd)
            if r:
                print("Welcome to login!")
            else:
                print("Failed to login!")
        else:
            user = input("Please input username:")
            pwd = input("Please input password:")
            r=register(user,pwd)
            print("Registered successfully")
      
    main()
    -----
    admin|123
    alex|123
    wuzb|999
    alex|9999

    Lambda表达式

  1. 三元运算

    执行逻辑：如果条件1成立，执行a；要不然执行b。

  2. lambda表达式：lambda a，b：a*b  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
if 1 == 1:
    name = "alex"
else:
    name = "SB"
# 如果 1==1 成立，
# name = "alex"
# 否则
# name = "SB"
name = "alex" if 1 == 2 else "SB"
print(name)
  
  
def f1(a1):
    return a1 + 100 # lambda a1:a1+100
  
f2 = lambda a1, a2=9: a1 + a2 + 100
  
ret = f1(10)
print(ret)
  
r2 = f2(9)
print(r2)
 
-----
SB
110
118

文件的操作

  • 普通打开方式

    操作文件时，一般需要经历如下步骤：

    • 打开文件

    • 操作文件

    一、打开文件

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

    注：python中打开文件有两种方式，即：open(...) 和  file(...) ，本质上前者在内部会调用后者来进行文件操作，推荐使用 open。

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

    打开文件的模式有：

    • r，只读模式（默认）。

    • w，只写模式。【不可读；不存在则创建；存在则删除内容；】

    • a，追加模式。【可读；   不存在则创建；存在则只追加内容；】

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

    • r+，可读写文件。【可读；可写；可追加】

    • w+，写读

    • a+，同a

    "U"表示在读取时，可以将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用）

    • rU

    • r+U

    "b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）

    • rb

    • wb

    • ab

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    # utf-8 一个汉字：三个字节
    # gbk 一个汉字：二个字节
    # utf-8
    s = "李杰"
    # 一个字节8位，一个汉字三个字节
    #  0101010 10101010 101010101  0101010 10101010 101010101
    #     23     23      23           23     23      23  15
    #     2f     2a      2c           2c     2e      2f  f
    # 字符串转换字节类型
    # bytes(只要转换的字符串， 按照什么编码）
    n = bytes("李杰", encoding="utf-8")
    print(n)
    n = bytes("李杰", encoding="gbk")
    print(n)
    # 字节转化成字符串
    new_str = str(bytes("李杰", encoding="utf-8"), encoding="utf-8")
    """

  • 使用with打开文件

    好处：为了避免打开文件后忘记关闭，可以通过管理上下文，如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。

    1
    2
    3
    with open('db','r',encoding='utf-8') as f:
        for line in f:
            print(line)

  • 文件的一些方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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()
 
2、操作文件
 
read() # 无参数，读全部；有参数，
                                   b，按字节
                                   无b，按字符
tell() 获取当前指针位置(字节)
seek(1) 指针跳转到指定位置(字节)
write（） 写数据，b，字节；无b，字符
close
fileno
flush 强刷
readline 仅读取一行
truncate 截断，指针为后的清空








posted @ 2016-11-13 18:23  Diligent小十  阅读(158)  评论(0)  编辑  收藏  举报