码迷，mamicode.com
首页 > 编程语言 > 详细

Python13_day3

时间：2016-11-13 19:47:29      阅读：241      评论：0      收藏：0      [点我收藏+]

标签：author   value   打开方式   视频   lambda表达式   大数   line   课程   square   

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 截断，指针为后的清空








Python13_day3

标签：author   value   打开方式   视频   lambda表达式   大数   line   课程   square   

原文地址：http://www.cnblogs.com/kakarott/p/6059429.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！