菜单

列表,元祖,字典小记

2019年2月10日 - www6165com

 

图片 1

一、数据类型

数据类型,相同类的值(指定类的对象)具有同样的效能,功效保存在类中(唯有一份)

 

1、列表格式:

注:元祖(超级元素)不可被修改,不可能被增加照旧去除; 
 有序的;

3.1.21 isalpha()

看清字符串的内容是或不是是纯字母

 图片 2

# True 1 False 0
# info ={
# “k1”: ‘asdf’,
# True: “123”,
# # [11,22]: 123
# (11,22): 123,
# # {‘k1′:’ v1′}: 123
#
# }
# print(info)

 

test='124'
v=test.isdecimal()      # 判断字符串是否只包含数字
print(v)

5.1.1 append()

在列表底部扩充一个值[修改本身值]

 图片 3

示例:

v = []
while True:
    name = input(“请输入用户名:”)
    if name.lower() == ‘q’:
        break
    
v.append(name)
    print(v)

 图片 4

图片 5图片 6

  print(li)

 

5.1.5 index()

找参数的岗位

 图片 7

 

  li=[‘alex’, ‘小名’, [12, 23, 45],
23, 23, ‘小花’]

a='0011'
v=int(a ,base=2)    # base=16/8/2  指代以16进制数,8进制数,2进制数表示a, 若是不写base=  则默认10进制数
print(v)

3.1.15 casefole()

字符串变小写,包罗小语种,lower()只可以改变英文

 图片 8

 

  列表中的元素得以是数字、字符串、列表、布尔值、等具有的都能放进去

  print(k,v)

3.1.16 center(),ljust(),rjust()

center():两边补字符

ljust():左侧补字符

rjust():左边补字符

 图片 9

图片 10图片 11

1、 append追加

    li = [11,22,33,44]

错误方法: v = li.append('alex')
          print(v)      打印出来为none,说明v中为空
因为字符串不能修改,而列表可以直接修改,所以:可以直接写

          li.append('alex')
          print(li)  打印结果为:[...'alex']
  或者: li.append(['alex'])
      print(li)  打印结果为: [...['alex']] 

2、clear清空列表

    li.clear()
    print(li)


3、copy拷贝
    浅拷贝:v=li.copy()
                print(v)


4、count 计算元素出现的次数

    v = li.count(22)
    print(v)


5、extend 扩展原列表
   参数必须是:iterable可迭代对象(能被for循环)

         li.extend([1992,'xiaowang'])
         print(li)
         打印结果为:[...,1992, 'xiaowang']
或者   li.extend('小王同学')
         print(li)
         打印结果为:['小',‘王‘,‘同’, ’学’]    

6、index 获取当前值的索引位置(最左优先)
         v =  li.index(22)
         print(v)
     或者可以选取范围
         v=li.index('alex',1,3)

7、insert 指定索引位置插入元素
     li.insert(位置,插入的值)
     例如: li.insert(0,'alex')
                print(li)


》》》》》》》》》补充《》《》《》《》《》《》
源码中出现:    index索引,value值


8、pop 删除指定位置的值
    不指定索引时,默认删除最后一个值,并获取删除的值
        v = li.pop()
        print(li)
        print(v)
   指定索引时,删除指定位置的值,并获取删除的值
        v = li.pop(1)
        print(li)
        print(v)

9、remove 删除列表中的指定值,左边优先(括号内要填入删除的内容)
        li.remove(11)
        print(li)

10、reverse 反转,将当前列表进行反转
  li.reverse()
    print(li)

11、sort排序
   从小到大排序:
      li.sort()
   从大到小排序
      li.sort(reverse=True)
   欠两个参数:讲函数时补充 cmp, key

8、

8.2中间原理

在硬盘内部存储以0101010样式储存,不过出口查看时以bytes格局显得

utf-8或gbk…

utf-8

    一个字符多个字节,内部用二进制表示

01100001      a

01101100       l

01100101      e

01111000      x

00000010 00000000 00000000 00000110 00000000 00000000  海娇

 

gbk

一个字符两个字节

00000000 01100001      a

00000000 01101100       l

00000000 01100101      e

00000000 01111000      x

 

10000010 00000000          海

10000010 00100000          娇

 

xxx

00000000 00000000 01100001     a

00000000 00000000 01101100     l

00000000 00000000 01100101     e

00000000 00000000 01111000     x

 图片 12

 8、 删除某个值(1.指定索引;2. 默许最终一个),并赢得删除的值
li = [11, 22, 33, 22, 44]
v = li.pop()
print(li)

  print(li[3])           print(li[3:-1])

6、

5.3 删除补充

除去列表元素时,会潜移默化列表长度,从而使得索引取值时,不难出现错误。

 图片 13

化解措施:

# 解决方案一: li = [11, 22, 33, 44, 66] # 0 new_list = []
# 索引为奇数值,删除
**
for i in range(0,len(li)):
    
if** i%2 == 0:
        new_list.append(li[i])
li = new_list
print(li)

 图片 14

# 解决方案二: li = [11, 22, 33, 44, 66] # 0
# 索引为奇数值,删除
#倒序删除rang(4,-1,-1)
**
for i in range(len(li)-1,-1,-1): # 4,0
    
if i%2 == 1:
        
del** li[i]
print(li)

 图片 15

# 解决方案三:
#切片+步长
li = [11, 22, 33, 44, 66]
#del li[0:4]
**
del** li[0:4:2]
print(li)

 图片 16

li = [1, 12, 9, "age", ["石振文", ["19", 10], "庞麦郎"], "alex", True]  # 通过list类创建的对象,li

         
列表是铁板钉钉的,列表元素可以被改动

test='\totijd\n'
v=test.isprintable()        # 判断是否存在不可见的(如\n、\t) ,或运行结果不可显示的字符  
print(v)

5、列表(list类)

可变的容器,本身是浮动的

# 2 按照Key获取值,key不设有时,可以指定默许值(None)
# v = dic[‘k11111’]
# print(v)
# v = dic.get(‘k1’,111111)
# print(v)

7、支持 in 操作

 四、元祖  tuple

7.1.4 items()

 图片 17

[11, 22, 33, 22]

  假如列表中即有数字又有字符串,要求协调写一个for循环

方法

6.1.1 len()

 图片 18

View Code

   v = ‘ ‘.join(li)

li = ['11', '22', '33', '44']
v = li.copy()                       # 浅拷贝   
print(v)

4.7 示例

# 面试题 a = False or 2 > 3
print(a)
#有现实数字依旧字符串时,输出数字或字符串 a = 9 or 2 > 3
print(a)
a = “asdf” or 2 > 3
print(a)

[11, 22, 33, 22, 44, [77, 99]]
>>> li = [11, 22, 33, 22, 44]
>>> li.index(22)
1        只查到第一个元素22所在的索引位置

5、元祖是萧规曹随的

3、支持for循环

7.1.3 values()

 图片 19

2,列表的在后面添台币素,方法为append()

4、extend增加,在元祖中同样适用

 

6.1 公共职能

  1. 在指定索引位置插入元素 ,方法为insert()

  布尔值,列表、字典不可能当做字典的key

1、

1、整数(int类)

   1,2,3,4…….99….

[11, 22, 33, 22, 44, 9898, ‘不得了’]

8、嵌套列表查询办法

七、集合:   s = {,,,}

4.5 bool–>str

str(bool)

print(v)

一、列表—-list

诚如方法:

11.2.3 symmetric_difference()、symmetric_difference_update()

铲除多少个聚众同时存在的值

symmetric_difference()

不改动原集合,改变未来的集合赋给一个新的变量

symmetric_difference_update()

直白修改原集合

 图片 20

# for item in info.values():
# print(item)

6、删除

print(v)

5.1.6 clear()

清空列表

 图片 21

图片 22图片 23

=====================list类中提供的办法===================

图片 24    程序报错

11.2.4 dicard()

在聚集中去除制定值

 图片 25

View Code

  li=[‘小王’,‘小宁’, [a, b, [d, e, f ],  c ], ‘小张’]

标准为:test.center(width,fillchar=None)

4.6 bool–>int

True–1

False–0

 图片 26

图片 27

View Code

3、可以通过索引取值,  或者切片取值(切片取值的结果也是列表)

2、for

7、字典(dict类)

>>> li = [11, 22, 33, 22, 44]
>>>
>>> li.extend(234) #如果输入的对象是不可迭代的,它会报错。
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

3、for循环

补充:

2、布尔型(bool类)

True 1

False 0

布尔值为False的场地:False : 0,None,”,{},[],()

1,建立列表,列表的要素得以分包其余数数据类型,可以是数字,字符串,列表,元组,字典,集合和布尔值

1、循环字典中所有的key
    for item in info.keys():
        print(item)


2、循环字典中的所有values(值)
    for item in info.values():
    prent(item)            


3、既要循环key又要循环字典中所有的值
     for item in info.keys():
        print(item,info[item])

     那么可以简写为:
    for k, v in info.items():
        print( k, v )

《》《》《》《》字典的方法《》《》《》《《》》
1、clear 清空

2、copy 浅拷贝

3、fromkeys  根据序列创建字典,并且制定统一的值
    用法: v= dict.fromkeys(['k1', 123, 'k2'], 22)

4、通过索引取key,如果字典中没有会直接报错
    get  用法:查找字典的key,key不存在时可以指定默认值

    方法一:
            dic = {"k1":23, "k2": 24}
            v= dic.get("k3")
            print(v)       如果k3不在字典中,则返回None
    方法二:
            dic = {"k1":23, "k2": 24}
            v= dic.get("k3",1111)
            print(v)       如果k3不在字典中,则返回1111      
5、items

6、 keys

7、 pop     删除。既可以指定所要删除的值,又可以拿到删除掉的值

        方法一:
        dic = {"k1":23, "k2": 24}
        v = dic.pop('k1') 
        print(dic,v)
       方法二:设定具体值,当要删除的key不存在时,返回到设置的值
         dic = {"k1":23, "k2": 24}
         v = dic.pop('k5',1111) 
         print(dic,v)   


8、  popitem随机删除,并返回删除的值

       dic = {"k1":23, "k2": 24}
        v,k = dic.popitem() 
        print(dic,v,k)   

9、setdefault设置值,如果值已经存在,并获取存在key对应的值
    如果key不存在,创建并获取新创建的key的值
   例如: dic = {"k1":23, "k2": 24}
             v = dic.setdefault("k111","alex") 
             print(dic,v)

10、update 更新

dic = {"k1":23, "k2": 24}
方法一:dic.update({'k1': 1111, 'k3',123})
            print(dic)
方法二: dic.update(k1=123, k3=345, k5='alex')
            print(dic)   

 

11.2.1 add()

添加

 图片 28

# 1、基本机构
# info = {
# “k1”: “v1”, # 键值对
# “k2”: “v2”
# }
#### 2 字典的value可以是其它值
# info = {
# “k1”: 18,
# “k2”: True,
# “k3”: [
# 11,
# [],
# (),
# 22,
# 33,
# {
# ‘kk1’: ‘vv1’,
# ‘kk2’: ‘vv2’,
# ‘kk3’: (11,22),
# }
# ],
# “k4”: (11,22,33,44)
# }
# print(info)

  li = [‘xiaozhang’, ‘xiaowang’]

5、相比运算

7.1.2 keys()

 图片 29

>>> li = [11, 22, 33, 22, 44]
>>> li.insert(0,99)  #指定在第一个位置插入99
>>> print(li)
[99, 11, 22, 33, 22, 44]
>>> li.insert(2,99)  #指定在第三个位置插入99
>>> print(li)
[99, 11, 99, 22, 33, 22, 44]

=================list之灰魔法================

      dic.popitem  随机删除

6、元组(tuple类)

不可变的器皿

唯有一个因素时,一定加逗号(1,)

二、元组功效及方式

  中括号括起来,

小心:找不到时 结果为-1

5.1 list类中提供的功效

 

2、删除key :   del info[“k1”]

test='苟陇辉苟'     # for 循环格式   for 变量名 in 字符串:
for v in test:      #                    变量名
    print(v)

5.1.4 remove()、del、pop()

删除

 图片 30

pop()不点名地点默认删除最终一个,重回删除元素的值

 图片 31

# 6 keys() 7 values() 8 items() get update
##########

  索引切片删除: del li [2,4]    print(li)

图片 32

7.1.5 update()

合并七个字典,假若有重复键则合并值,没有重新的键则添加值

 图片 33

图片 34

# 4 设置值,
# 已存在,不安装,获取当前key对应的值
# 不存在,设置,获取当前key对应的值
# dic = {
# “k1”: ‘v1’,
# “k2”: ‘v2’
# }
# v = dic.setdefault(‘k1111′,’123’)
# print(dic,v)

info = {"k1": "v1", "k2": "v2"}        键值对

对象   info = {‘k1′:’v1′,’k2′:’v2’}

5.1.3 reverse()

v = [11,22,33,44]
print(v)
v.reverse()
print(v)

 图片 35

图片 36图片 37

  逗号分隔每个元素,

图片 38

6.1.4 嵌套

v =
(11,22,[11,22,33],33,(9,1,2,“alex”),44)#外甥不可变,外孙子可能可变 v[2][1] = “xxxxx” print(v)
v[2].append(“asdasd”)
print(v)

 图片 39

10、 索引取值

》》》》》》》》两个方法《》《》《》《》《》《
count 获取指定元素在元祖中出现的次数
index 获取某个指定元素的索引,可以设定起始位置查找

 

3.1.20 isdigit()

认清字符串的始末是不是是纯数字

 图片 40

 li = [11, 22, 33, 22, 44]
v = li.pop(1)
 print(li)

   print (v)

test='alexalexalex'
v=test.replace('al','bbb',2)        # 替换功能
print(v)

3.1.17 count()

算算个数

 图片 41

# 3 删除并获取值
# dic = {
# “k1”: ‘v1’,
# “k2”: ‘v2’
# }
# v = dic.pop(‘k1’,90)
# print(dic,v)
# k,v = dic.popitem()
# print(dic,k,v)

    for i in li :

 

11.2.5 intersection()、intersection_update()

求交集

intersection()

不改动原集合,改变之后的集合赋给一个新的变量

intersection_update()

直接改动原集合

 图片 42

View Code

  索引切片修改: li [1:3] = [27, 28]

 

5.1.9 copy()

复制、浅拷贝

 图片 43

有一个特点:浅copy,只copy第一层

现在的急需是要出口的names2与第一行names定义的一律

name1 = [“zhangyang”,“guyun”,“xiangpeng”,“xulang”]
name2 = name1.copy()
name1[1] = “古云” print(name1)
print(name2)

 图片 44

name1 =
[“zhangyang”,“guyun”,“xiangpeng”,[“jack”,“alex”],“xulang”]
name2 = name1.copy()
name1[1] = “古云” name1[3][0] = “杰克” print(name1)
print(name2)

 图片 45

列表的特性

 图片 46

与字符串或数字差异

 图片 47

深拷贝

import copy
name1 =
[“zhangyang”,“guyun”,“xiangpeng”,[“jack”,“alex”],“xulang”]
name2 = copy.deepcopy(name1)
name1[1] = “古云” name1[3][0] = “杰克” print(name1)
print(name2)

 图片 48

简述深浅拷贝

#假如拷贝单层列表时,深浅拷贝都把原列表拷贝到了一个新的内存地址,所以原列表被改动新列表都不会被改动

#如果拷贝多层列表时

    #浅拷贝只将原列表的首先层拷贝到了新的内存地址,新列表二层及以内的依旧指向原列表的内存地址,所以原列表被涂改,新列表的

    #先是层不会转移,二层及以内的会跟着新列表修改

    #深拷贝是将原列表的具有都拷贝到了新的内存地址,原列表被改动,新列表不会变动

 2 清空列表
li.clear()
print(li)

 二、元祖
tuple     

 二者的区分为  若为 ② 则 .isdecimal 为false       . isdigit 为true   

5.2.2 索引

 图片 49

>>> li = [11, 22, 33, 22, 44]
>>> li.append([77,99])
>>> print(li)
[11, 22, 33, 22, 44, [77, 99]]

    li = [12,13,14,’xiaozhang’, ‘xiaowang’]

使用for语句时:

4.4 int–>bool

0–False

其他–True

 图片 50

li = [11, 22, 33, 22, 44]
li.append([9898,"不得了"])
print(li)

  “集合“,”内部能够停扬弃何事物

图片 51

5.1.8 extend()

合并

 图片 52

# 4 字典无序

    s=’ ‘

     假: 
空字典,空列表,空元祖,空字符串,0

7.1 dict类中提供的机能

图片 53图片 54

  若列表中的元素只有字符串,直接用字符串join方法

   print(v)

3.1.19 index()

列表字符的目录

 图片 55

11,切片,切片结果也是列表

5、列表元素可以拓展改动

图片 56

3.1 字符串提供的效果

3.1.1 upper()

变大写

 图片 57

3.1.2 lower()

变小写

 图片 58

3.1.3 capitalize()

首字母变大写,别的变小写

 图片 59

3.1.4 strip()

去除首尾空格、换行、制表符、制定的情节

 图片 60

示例:

 图片 61

3.1.5 lstrip()

删去右侧空格

 图片 62

3.1.6 rstrip()

删除左侧空格

 图片 63

3.1.7 replace()

替换

 图片 64

图片 65

 

 图片 66

图片 67

3.1.8 split()

分割

 图片 68

图片 69

图片 70

图片 71

3.1.9 isdecimal()

认清当前字符串中是还是不是全部都是数字

 图片 72

示例:

count = 0
v = “abc123fsdfa3f”
for
item in v:
    if item.isdecimal():
        count += 1
print(count)

 图片 73

 

# 7 for循环
# dict
# info = {
# “k1”: 18,
# 2: True,
# “k3”: [
# 11,
# [],
# (),
# 22,
# 33,
# {
# ‘kk1’: ‘vv1’,
# ‘kk2’: ‘vv2’,
# ‘kk3’: (11,22),
# }
# ],
# “k4”: (11,22,33,44)
# }
# for item in info:
# print(item)
#
# for item in info.keys():
# print(item)

v = info[key]    例如: v=info[“k1”]

 

7.2.3 设置

# key存在,则更新值
# key不设有,则创制键值对
v = {
    “k1”:‘v1’, # 键值对
    **
“k2”:‘v2’, # 键值对 }
v[
‘kk1’] = 666
v[
‘k1’**] = 777
print(v)

 图片 74

# for k,v in info.items():
# print(k,v)

5、元祖的一级元素不可被改动,元祖中嵌套的列表可以被涂改

 

5.2.6 嵌套

列表中的元素得以是:数字,字符串,布尔值,列表

li = [11,22,[6,“88991”,7],33,True,“蒋毅”,55]
val = li[2][1][-1]
print(val)

li[3] = 66
print(li)

li[2][2] = 77
print(li)

li[2][1] = 666
print(li)

li[5] = li[5].replace(‘蒋’,‘江’)
li[5] = “江毅” print(li)

 图片 75

33

  字典的value可以是其余值

图片 76

5.1.2 insert()

在指定地点插入数据

v = [11,22,33,44,“蒋毅”]
v.insert(4,“孙骑兵”)#4是下标 print(v)

 图片 77

# 5 更新
# dic = {
# “k1”: ‘v1’,
# “k2”: ‘v2’
# }
# dic.update({‘k1’: ‘111111’,’k3′: 123})
# print(dic)
# dic.update(k1=123,k3=345,k5=”asdf”)
# print(dic)

  索引删除: del li [1]     print(li)

 

11.2 功能

列表list在Python中实际就是一个类,赋值后就是调用那一个类的一个目的,list.xx()就是目的的不二法门,也可称为参数。

3、因为是可迭代对象:字符串、列表、元祖可以相互转换

tu =
(111,’alex’,(,),[()],True,33,44,)

5.2.4 替换

 图片 78

5.
伸张原列表,参数:可迭代对象,方法为extend()会把一个可迭代的对象,迭代出来作为元素参与到列表中,也就是替我们用For循环逐个加盟到列表。

9、字符串转换成列表

 

3.2 公共职能

3.2.1 len()

总结当前字符串长度

 图片 79

 

3.2.2 索引、下标

#      –  单个值:v[0]

#      –  多个值:v[初步地方:截止地点]

#      –  多个值:v[开第四地方:甘休地方:步长]

#      PS: -1表示最终

 图片 80

图片 81

图片 82

图片 83

示例:

*# 题: 列出v = “ASCII第两回以标准标准的型态发”
# v = “ASCII第五遍以规范标准的型态发”
# length = len(v)
# index = 0
# while True:
#     data = v[index]
#     print(data)
#     index += 1
#     if index == length:
#         break

*v = “ASCII第五回以专业标准的型态发” length = len(v)
index = 0
while index < length:
    data = v[index]
    print(data)
    index += 1

 

 

3.2.3 循环 

图片 84

图片 85

 

View Code

  s=’abcdefg’

 

11.2.7 isdisjoint()

判断是不是无交集

 图片 86

View Code

三、字典 dict

test='AleX'
v=test.casefold()          #表所有字母变小写
print(v)

4.3 int–>str

str(int)

 图片 87

# 5、索引格局找到指定元素
# info = {
# “k1”: 18,
# 2: True,
# “k3”: [
# 11,
# [],
# (),
# 22,
# 33,
# {
# ‘kk1’: ‘vv1’,
# ‘kk2’: ‘vv2’,
# ‘kk3’: (11,22),
# }
# ],
# “k4”: (11,22,33,44)
# }
# # v = info[‘k1’]
# # print(v)
# # v = info[2]
# # print(v)
# v = info[‘k3’][5][‘kk3’][0]
# print(v)

  1、可通过索引取值,切片取值

图片 88

10、复数(complex类)

#复数 = #实数 #虚数

#复数 = 实部 + 虚部

#a+bj

 图片 89

  1. 去除列表中的指定值,右侧优先  方法remove()
    li = [11, 22, 33, 22, 44]
    li.remove(22)
    print(li)

   tu = (11, ‘alex’,  ( 28, 29 ), 22, [33, 44 ], 55)

test='苟陇辉五六七八九'
v='_'.join(test)        # 将字符串中的每一个元素按照指定分隔符拼接。 注意    .join
print(v)

11.2.10 update()

更新

 图片 90

三、字典的功效和格局

2、列表中得以嵌套任何类型

八、字符串格式化

5.2 公共职能

图片 91图片 92

  li = list(s)

test='alexalex'
v=test.count('ex')      # 去字符串里寻找子序列('ex')出现的次数
print(v)

11、集合(set类)

# for item in info.keys():
# print(item,info[item])

4、支持for循环,   while循环。

 

7.2.4 删除

del

 图片 93

它与append的异样在于,append会把整个输入对象作为一个元素参与到列表的前面。

10、列表转换成字符串

图片 94

6.1.3 循环

for

 图片 95

图片 96图片 97

      s=s+str(i)

7、

11.2.12 len()

长度

 图片 98

[33,22]

  元素不可被改动,且元素不能被扩充依然去除,可是可以被翻动

3、

7.3 示例

# 示例: user_list = [
    {‘name’:‘老头’,‘age’: 18},
    {‘name’:‘流量’,‘age’: 66},
    {‘name’:‘wifi’,‘age’: 99},
]

n = input(“请输入姓名:”)
a = input(“请输入年龄:”)
temp = {‘name’: n, ‘age’: int(a)}
user_list.append(temp)
for item in user_list:
    print(item[‘name’],item[‘age’])

 图片 99

View Code

  索引修改: li [ 2 ] =120    print(li)

布尔值:  结果 为‘真’  true   或者 结果为 
‘假’  false

6.1.2 索引

 图片 100

 4. 盘算元素出现的次数
 v = li.count(22)
 print(v)

    print(s)

② 唯有字符串

4.2 str–>bool

空值字符串–False

其他–True

 图片 101

图片 102

 

  v = ‘alex’ in li         print(li)

图片 103

bit_length()

当下十进制用二进制表示时,最少使用的位数

 

v = 15
# 当前十进制用二进制表示时,最少使用的位数 data = v.bit_length()
print(v)
print(data)

 图片 104

print(li[3])

        依据惯例一般在最终价格逗号来识别

                 v=’alexalexalex’

5.2.5 删除

del

 图片 105

图片 106

44

2、可以拓展for循环(可迭代对象)

 

3.1.14 format()

格式化字符串

(1)

 图片 107

(2)

 图片 108

(3)

 图片 109

(4)

 图片 110

一、列表功效及措施

  print(li[2][2][0])

for item in info.values       
循环‘values’

3、字符串(str类)

字符串调用函数时,字符串本身原值不变

# 字典
# dict
# dict
# dic = {
# “k1”: ‘v1’,
# “k2”: ‘v2’
# }
# 1 根据系列,创设字典,并指定统一的值
# v = dict.fromkeys([“k1″,123,”999”],123)
# print(v)

1、查找字典内容

s=”

3.1.18 expandtabs()

可以一起换行符制表符使用,固定字符间隔长度

 图片 111

# \n ,换行符
# \t,制表符,相当于Tab缩进

#### 3 布尔值(1,0)、列表、字典无法看做字典的key
# info ={
# 1: ‘asdf’,
# “k1”: ‘asdf’,
# True: “123”,
# # [11,22]: 123
# (11,22): 123,
# # {‘k1′:’v1’}: 123
#
# }
# print(info)

 

11.2.11 for循环

 图片 112

 [22, 33, 22, 44]
 print(v)

2、切片取值:v = tu[0:2]

5.1.7 sort()

排序

按ASCII码排序

 图片 113

图片 114

li = [11, 22, 33, 22, 44]

 一、整形  int   

7.2 公共职能

1 li = [11, 22, 33, 22, 44]
2  li.append(5)
3  li.append("alex")
4  li.append([1234,2323])
5  print(li)
test='i am {name},age{a}'
v=test.format_map({'name':'alex','a':19})     # 也是格式化,将一个字符串的占位符替换为指定的值。注意格式的准确性,冒号不能少
print(v)

11.3 各个型转换

 图片 115

 

li = [11, 22, 33, 22, 44]
print(li[2:4])   取值的目录范围 大于等2,小于4.

li = [11,22,33,22,44]
v = li.index(22)                # 寻找当前元素的索引,找到第一个之后就不在找了
print(v)
v = li.index(22,2,4)            # 可加起始位置
print(v)
v = li.insert(0,99)             # 在指定位置0, 插入指定元素99
print(v)

7.2.2 获取

 图片 116

[11,  33, 22, 44]     只删除首个要素22
PS: pop 默许从最后一个刨除, remove默认左边优先,  del
li[0] 删除指定索引地方的因素   del li[7:9] 切片整段删除, 
clear清空列表。

           ②:无序

5.2.1 len()

统计列表长度

 图片 117

3 拷贝,浅拷贝
v = li.copy()
 print(v)

六、BOOL值

9、浮点数(float类)

#小数

    #有限小数

    #最好循环小数 3.33333 、4.404404

#无限不循环小数  派

#浮点数

    #有限小数

#可是循环小数 3.33333 、4.404404

 图片 118

输出结果为:

li = [1,12,9,'age',['苟陇辉',[19,10],'你'],'alex',True]

8.1表现格局

name = b’alex’

name = b’\x12\x86\xdf\xdf\xa8\x34….’  #不在ascii表中的字符,汉语字符

元组,元素不可被涂改,无法被增添或者去除
tuple
tu = (11,22,33,44)
tu.count(22),获取指定元素在元组中出现的次数
tu.index(22)

 

3.1.10 join()

接连列表的要素

 图片 119

  1. 根据值获取当前值索引地点(左侧优先)方法为index(xx)
test='alexex'
v=test.find('ex')       # 从开始往后找,找到第一个之后,获取其位置
print(v)

3.1.11 endswith()、startswith()

print(name.endswith(‘SB’))#判断是不是以’SB’结尾 print(name.startswith(‘alex’))#认清是还是不是以’alex’开始

 图片 120

# 6 字典协助 del 删除
# info = {
# “k1”: 18,
# 2: True,
# “k3”: [
# 11,
# [],
# (),
# 22,
# 33,
# {
# ‘kk1’: ‘vv1’,
# ‘kk2’: ‘vv2’,
# ‘kk3’: (11,22),
# }
# ],
# “k4”: (11,22,33,44)
# }
# del info[‘k1’]
#
# del info[‘k3’][5][‘kk1’]
# print(info)

test='二2②'
v=test.isnumeric()      # 判断是否全为数字  可识别汉字
print(v)

8、字节(bytes类)

bytes

貌似网络传输和硬盘存储使用bytes类型

# info = {
# “k1”: 18,
# “k2”: True,
# “k3”: [
# 11,
# [],
# (),
# 22,
# 33,
# {
# ‘kk1’: ‘vv1’,
# ‘kk2’: ‘vv2’,
# ‘kk3’: (11,22),
# }
# ],
# “k4”: (11,22,33,44)
# }
# print(info)

name='苟陇辉'
 if '苟' in name:
    print('ok')
else:
    print('error')

 if '苟'not in name:
    print('ok')
else:
   print('error')

7.1.1 get()

根据key获取相应的值,key不设有默许取None

 图片 121

11

 

3.1.12 encode(‘utf-8或gbk’)

把字符串转化成字节

 图片 122

图片 123

for item in li

4.1 str–>int

示例:

#加法计算器 v1 = input(“请输入第三个值:”) # “54” v2 = input(“请输入第一个值:”)
v3 = int(v1) + int(v2)
print(v3)

 图片 124

 图片 125

11.2.8 issubset()、issuperset()

issubset() 是不是是子集

issuperset()是还是不是是父集

 图片 126

a= 1>5

5.2.3 循环

for

 图片 127

  ‘转换bool值     

7.4 删除补充

不要在循环当前字典的经过中,修改当前字典大小

# 题1:dic = {‘k1′:”v1″,’k2′:’v2’}把key=”k1″,键值对删除

 图片 128

# 题2:dic =
{‘u1′:”v1″,’k2′:’v2′,’k3′:’v3’}把key中存在k,键值对删除

错误:

 图片 129

正确:

# 正确方法 dic_key_list = []
for key in dic:
    dic_key_list.append(key)

for row in dic_key_list:
    if ‘k’ in row:
        del dic[row]
print(dic)

 图片 130

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图