Python13_day3

于 2016-11-13 18:23:00 发布
阅读量57 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： python
原文链接：http://www.cnblogs.com/kakarott/p/6059429.html
本文介绍了Python的学习方法及set数据类型的特性与操作方法，包括构建、更新、求差集、交集等，并提供了丰富的示例代码。

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








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

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值