博客
关于我
强烈建议你试试无所不能的chatGPT，快点击我
Python13_day3
阅读量：6262 次
发布时间：2019-06-22

本文共 8232 字，大约阅读时间需要 27 分钟。

学习流程

一、基本的学习方法

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

转载于:https://www.cnblogs.com/kakarott/p/6059429.html

你可能感兴趣的文章
python XML
查看>>
html3秒跳转
查看>>
机器学习与R语言
查看>>
反距离权重插值inverse distance weighting，IDW
查看>>
2017第18周六
查看>>
Postman 网络调试工具
查看>>
hive建表范例
查看>>
【转】svn 的开发目录结构和流程
查看>>
水晶报表使用IEnumerable<T>数据源
查看>>
阿里面试的一点感受
查看>>
IE 窗口缩小css-IE,firefox居中的区别
查看>>
jQuery ajax - get() 方法
查看>>
opengl
查看>>
撒列实现关键字过滤，速度可快了
查看>>
将不确定变为确定系列~目录（“机器最能证明一切”）
查看>>
ListView 控件的使用
查看>>
奇怪的WinSCP登录问题
查看>>
UBUNTU中安装SMPLAYER
查看>>
[zz]struct epoll_event
查看>>
[PAL编程规范]SAP HANA PAL线性回归预测分析Linear Regression编程规范LRREGRESSION（模型）...
查看>>
喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！-- 愿君每日到此一游！
当前时间: 2025-01-09 10:59:06   当前IP: 18.220.255.227   联系邮箱:javaeecc@qq.com     Copyright © 2020 - 2022 baihongyu.com 京ICP备2021015314号-2
强烈建议你试试无所不能的CHAT-GPT，快点击我
强烈建议你试试无所不能的CHAT-GPT，快点击我