【home88一必发】数据类型,python基本数据类型之

by admin on 2019年1月31日

一、列表—-list

1、算数运算符:

一、数据类型

数据类型,相同类的值(指定类的目标)具有同样的效果,效用保存在类中(只有一份)

一、列表作用及方法

         
列表是严守原地的,列表元素可以被改动

+   –  *  /   **    %  //  

1、整数(int类)

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

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

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

num=9%2

bit_length()

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

 

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

 home88一必发 1

home88一必发 2home88一必发 3

1、列表格式:

print(num)

2、布尔型(bool类)

True 1

False 0

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

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

  中括号括起来,

num=9%2
print(num)


num=9//2
print(num )

3、字符串(str类)

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

View Code

  逗号分隔每个元素,

2、成员运算

3.1 字符串提供的功效

3.1.1 upper()

变大写

 home88一必发 4

3.1.2 lower()

变小写

 home88一必发 5

3.1.3 capitalize()

首字母变大写,其他变小写

 home88一必发 6

3.1.4 strip()

删去首尾空格、换行、制表符、制定的内容

 home88一必发 7

示例:

 home88一必发 8

3.1.5 lstrip()

剔除左边空格

 home88一必发 9

3.1.6 rstrip()

除去右侧空格

 home88一必发 10

3.1.7 replace()

替换

 home88一必发 11

home88一必发 12

 

 home88一必发 13

home88一必发 14

3.1.8 split()

分割

 home88一必发 15

home88一必发 16

home88一必发 17

home88一必发 18

3.1.9 isdecimal()

看清当前字符串中是或不是全部都是数字

 home88一必发 19

示例:

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

 home88一必发 20

 

列表list在Python中实际上就是一个类,赋值后就是调用这些类的一个对象,list.xx()就是目标的点子,也可称之为参数。

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

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

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

3.1.10 join()

接二连三列表的要素

 home88一必发 21

2,列表的在背后添英镑素,方法为append()

  “集合“,”内部可以停甩掉何东西

in             not in   判断某个东西是还是不是在某个东西中包罗。

3.1.11 endswith()、startswith()

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

 home88一必发 22

home88一必发 23home88一必发 24

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

3、逻辑运算

3.1.12 encode(‘utf-8或gbk’)

把字符串转化成字节

 home88一必发 25

home88一必发 26

1 li = [11, 22, 33, 22, 44]
2  li.append(5)
3  li.append("alex")
4  li.append([1234,2323])
5  print(li)

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

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

3.1.13 find()、index()

find()

在字符串中寻找,找不到再次回到-1

 home88一必发 27

 

index()

在字符串中寻觅,找不到报错

 home88一必发 28

View Code

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

# ” 空字符为假

3.1.14 format()

格式化字符串

(1)

 home88一必发 29

(2)

 home88一必发 30

(3)

 home88一必发 31

(4)

 home88一必发 32

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

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

# ‘   ‘  只要其中有东西 就为真

3.1.15 casefole()

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

 home88一必发 33

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

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

#  0    假

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

center():两边补字符

ljust():左侧补字符

rjust():左边补字符

 home88一必发 34

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

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

# 其他  真

3.1.17 count()

总结个数

 home88一必发 35

5.
恢宏原列表,参数:可迭代对象,方法为extend()会把一个可迭代的靶子,迭代出来作为元素参加到列表中,也就是替大家用For循环逐个投入到列表。

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

  ‘转换bool值     

3.1.18 expandtabs()

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

 home88一必发 36

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

home88一必发 37home88一必发 38

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

a=123

3.1.19 index()

列表字符的目录

 home88一必发 39

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

6、删除

b=bool(a )’

3.1.20 isdigit()

判断字符串的始末是不是是纯数字

 home88一必发 40

View Code

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

name='苟陇辉'
v= '苟' in name
print(v)

user='alex'
pwd=123
v=user=='alex' and pwd==124 or user=='ales'and pwd=='123' print(v)

3.1.21 isalpha()

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

 home88一必发 41

出口结果为:

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

4、赋值运算

3.1.22 isspace()

 home88一必发 42

home88一必发 43home88一必发 44

7、支持 in 操作

count=1

3.2 公共职能

3.2.1 len()

算算当前字符串长度

 home88一必发 45

 

3.2.2 索引、下标

#      –  单个值:v[0]

#      –  多个值:v[开第四地点:停止地点]

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

#      PS: -1表示最终

 home88一必发 46

home88一必发 47

home88一必发 48

home88一必发 49

示例:

*# 题: 列出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 循环 

home88一必发 50

home88一必发 51

 

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

  v = ‘alex’ in li         print(li)

count=count+1  即  count+=1

4、int-bool-str转换

int    89  90

bool   True False

str  ‘sdf’ ‘7’

View Code

8、嵌套列表查询形式

count=count%1 即 count%=1

4.1 str–>int

示例:

#加法总括器 v1 = input(“请输入首个值:”) # “54” v2 = input(“请输入首个值:”)
v3 = int(v1) + int(v2)
print(v3)

 home88一必发 52

 

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

5、相比运算

4.2 str–>bool

空值字符串–False

其他–True

【home88一必发】数据类型,python基本数据类型之。 home88一必发 53

home88一必发 54

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

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

a= 1>5

4.3 int–>str

str(int)

 home88一必发 55

home88一必发 56home88一必发 57

9、字符串转换成列表

print(a)

4.4 int–>bool

0–False

其他–True

 home88一必发 58

>>> 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

  s=’abcdefg’

结果为 false

4.5 bool–>str

str(bool)

View Code

  li = list(s)

 

4.6 bool–>int

True–1

False–0

 home88一必发 59

home88一必发 60

它与append的异样在于,append会把全副输入对象作为一个元素参加到列表的背后。

  print(li)

小结: 算数运算符 和 赋值运算符 得到的均为‘’真实‘’结果;相比较运算符、
逻辑运算符、成员运算得到的结果均为“布尔值”

4.7 示例

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

 

10、列表转换成字符串

主导数据类型

5、列表(list类)

可变的容器,本身是转变的

  1. 据悉值获取当前值索引地点(左边优先)方法为index(xx)

  若是列表中即有数字又有字符串,要求团结写一个for循环

 一、整形  int   

5.1 list类中提供的效果

home88一必发 61home88一必发 62

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

注:在Python3中,无论数字多大,都属于int类型;在Python2中,数字变大,超过一定范围则号称long型;

5.1.1 append()

在列表尾部扩展一个值[修改本身值]

 home88一必发 63

示例:

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

 home88一必发 64

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

    s=’ ‘

魔法  

5.1.2 insert()

在指定地点插入数据

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

 home88一必发 65

View Code

    for i in li :

1、转换职能

5.1.3 reverse()

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

 home88一必发 66

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

      s=s+str(i)

a='123'
print(type(a),a)     # type 查看类型 
b=int(a)             # 将字符串'123',转换为数字123
print(type(b),b)

5.1.4 remove()、del、pop()

删除

 home88一必发 67

pop()不点名地方默许删除最终一个,再次来到删除元素的值

 home88一必发 68

home88一必发 69home88一必发 70

    print(s)

home88一必发 71

5.1.5 index()

找参数的地点

 home88一必发 72

>>> 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]

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

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

5.1.6 clear()

清空列表

 home88一必发 73

View Code

  li = [‘xiaozhang’, ‘xiaowang’]

home88一必发 74

【home88一必发】数据类型,python基本数据类型之。5.1.7 sort()

排序

按ASCII码排序

 home88一必发 75

home88一必发 76

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

   v = ‘ ‘.join(li)

2、

5.1.8 extend()

合并

 home88一必发 77

[11, 22, 33, 22]

   print (v)

age=10
r=age.bit_length()    #表示当前数字的二进制,至少用多少位表示  10的二进制数为1010 即4位
print(r)

5.1.9 copy()

复制、浅拷贝

 home88一必发 78

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

前些天的必要是要出口的names2与第一行names定义的等同

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

 home88一必发 79

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

 home88一必发 80

列表的特色

 home88一必发 81

与字符串或数字分歧

 home88一必发 82

深拷贝

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

 home88一必发 83

简述深浅拷贝

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

#一经拷贝多层列表时

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

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

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

print(v)

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

home88一必发 84

5.2 公共职能

44

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

二、字符型

5.2.1 len()

测算列表长度

 home88一必发 85

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

 二、元祖
tuple     

魔法 

5.2.2 索引

 home88一必发 86

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

  元素不可被改动,且元素不可以被扩大仍旧去除,可是足以被翻动

1、

5.2.3 循环

for

 home88一必发 87

11

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

test='alex'
v=test.capitalize()         #表示首字母大写
print(v)

5.2.4 替换

 home88一必发 88

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

        依据常规一般在最后价格逗号来识别

home88一必发 89

5.2.5 删除

del

 home88一必发 90

home88一必发 91

[11,  33, 22, 44]     只删除第三个要素22
PS: pop 默许从最终一个删减, remove默许左边优先,  del
li[0] 删除指定索引位置的元素   del li[7:9] 切片整段删除, 
clear清空列表。

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

2、

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)

 home88一必发 92

 

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

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

5.3 删除补充

剔除列表元素时,会影响列表长度,从而使得索引取值时,简单并发谬误。

 home88一必发 93

焚林而猎办法:

# 解决方案一: 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)

 home88一必发 94

# 解决方案二: 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)

 home88一必发 95

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

 home88一必发 96

10、 索引取值

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

home88一必发 97

6、元组(tuple类)

不可变的器皿

只有一个元素时,一定加逗号(1,)

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

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

注意:

6.1 公共职能

print(li[3])

5、元祖是雷打不动的

test='AleX'
v=test.lower()          #也表所有字母变小写,但是特殊字符表示不了。而capitalize()则对于很多未知的对应关系也可以表示
print(v)

6.1.1 len()

 home88一必发 98

33

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

home88一必发 99

6.1.2 索引

 home88一必发 100

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

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

3、

6.1.3 循环

for

 home88一必发 101

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

三、字典 dict

test='aLex'
v=test.center(20,'*')       # 表示  设置宽度,并将内容居中,其中20代表总长度,'*'代表空白处的未知填充,只能有一个字符,可有可无
print(v)

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)

 home88一必发 102

[33,22]

  字典的value可以是其余值

home88一必发 103

7、字典(dict类)

 

 

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

7.1 dict类中提供的效率

二、元组功用及方法

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

4、

7.1.1 get()

据悉key获取相应的值,key不存在默许取None

 home88一必发 104

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

  布尔值,列表、字典无法当做字典的key

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

7.1.2 keys()

 home88一必发 105

三、字典的机能和措施

1、查找字典内容

 home88一必发 106

7.1.3 values()

 home88一必发 107

# 字典
# dict
# dict
# dic = {
# “k1”: ‘v1’,
# “k2”: ‘v2’
# }
# 1 依据种类,成立字典,并点名统一的值
# v = dict.fromkeys([“k1″,123,”999”],123)
# print(v)

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

test='alexalex'
v=test.count('ex',5,8)      # 去字符串里寻找子序列('ex')出现的次数,指定寻找的起始 和 结束 位置  注意字符串第一位为0
print(v)

7.1.4 items()

 home88一必发 108

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

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

home88一必发 109

7.1.5 update()

统一八个字典,如果有重复键则合并值,没有再度的键则添加值

 home88一必发 110

home88一必发 111

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

3、for循环

5、

7.2 公共职能

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

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)   
test='alex'
v=test.endswith('ex')      #  字符串以什么结尾 
print(v)                   #  v=test.startswith('a') 表示字符串以什么开头   

7.2.1 len()

 home88一必发 112

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

 

home88一必发 113

7.2.2 获取

 home88一必发 114

#home88一必发, 6 keys() 7 values() 8 items() get update
##########

6、

7.2.3 设置

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

 home88一必发 115

 

test='alexalex'
v=test.find('ex',5,8)       # 从开始往后找,获取其位置 ,可指定其寻找的起始位置,注意,大于等于5,小于8
print(v)

7.2.4 删除

del

 home88一必发 116

# 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)

home88一必发 117

7.2.5 循环

for

 home88一必发 118

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

只顾:找不到时 结果为-1

7.2.6 嵌套

val = {
    ‘k1’: 123,
    ‘k2’: “asdf”,
    ‘k3’: True,
    ‘k4’: [11,22,33],
    ‘k5’: (1,2,3),
    ‘k6’: {
        ‘kk1’:‘vv1’,
        ‘kk2’:‘vv2’,
    },
    ‘k7’: [1,2,(8,6,2),{“k111”:‘vvv1’},5]
}

 

# 4 字典无序

7、

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’])

 home88一必发 119

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

test='alexalex'
v=test.index('8')           #  从开始往后找,获取其位置 ,可指定其寻找的起始位置,找不到时程序报错,故一般使用find命令,找不到时 运行结果为-1
print(v)

7.4 删除补充

并非在循环当前字典的长河中,修改当前字典大小

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

 home88一必发 120

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

错误:

 home88一必发 121

正确:

# 正确方法 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)

 home88一必发 122

# 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)

home88一必发 123    程序报错

8、字节(bytes类)

bytes

诚如互联网传输和硬盘存储使用bytes类型

# 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)

8、

8.1表现格局

name = b’alex’

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

# 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)

test='i am {name},age{a}'
v=test.format(name='alex',a=19)     # 格式化,将一个字符串的占位符替换为指定的值。注意格式的准确性,括号必须为大括号
print(v)

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

 home88一必发 124

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

home88一必发 125

9、浮点数(float类)

#小数

    #有限小数

    #极致循环小数 3.33333 、4.404404

#无限不循环小数  派

#浮点数

    #有限小数

#最好循环小数 3.33333 、4.404404

 home88一必发 126

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

test='i am {name},age{a}'
v=test.format_map({'name':'alex','a':19})     # 也是格式化,将一个字符串的占位符替换为指定的值。注意格式的准确性,冒号不能少
print(v)

10、复数(complex类)

#复数 = #实数 #虚数

#复数 = 实部 + 虚部

#a+bj

 home88一必发 127

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

home88一必发 128

11、集合(set类)

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

9、

11.1 性质

聚拢的因素无重复,能够做急迅去重的格局

见面是可变数据类型

聚集内部不可能加可变数据类型,如列表,列表

聚拢内部因素时不可变数据类型

集合内部不可以嵌套集合

 

test='syeijc435_+'
v=test.isalnum()        # 判断字符串中是否只包含字母和数字,若有其他符号 ,则结果为false
print(v)

11.2 功能

home88一必发 129

11.2.1 add()

添加

 home88一必发 130

10、

11.2.2 difference()、difference_update()

差集

difference()

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

 home88一必发 131

difference_update()

从来修改原集合

 home88一必发 132

test='tuys'
v=test.isalpha()        # 判断字符串是否只包含字母 汉字
print(v)

11.2.3 symmetric_difference()、symmetric_difference_update()

免去多个汇聚同时存在的值

symmetric_difference()

不修改原集合,改变将来的集合赋给一个新的变量

symmetric_difference_update()

直白修改原集合

 home88一必发 133

home88一必发 134

11.2.4 dicard()

在集结中剔除制定值

 home88一必发 135

11、

11.2.5 intersection()、intersection_update()

求交集

intersection()

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

intersection_update()

直白修改原集合

 home88一必发 136

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

11.2.6 union()

求并集

 home88一必发 137

home88一必发 138

11.2.7 isdisjoint()

判断是还是不是无交集

 home88一必发 139

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

11.2.8 issubset()、issuperset()

issubset() 是或不是是子集

issuperset()是或不是是父集

 home88一必发 140

home88一必发 141

11.2.9 pop()、remove()、discard()

去除集合的因素

pop()

删去元素并回到该因素

 home88一必发 142

remove()

删除,如若元素不存在会报错

 home88一必发 143

discard()

去除,假诺元素不设有不会报错

 home88一必发 144

 

11.2.10 update()

更新

 home88一必发 145

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

11.2.11 for循环

 home88一必发 146

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

11.2.12 len()

长度

 home88一必发 147

 home88一必发 148

11.3 各个型转换

 home88一必发 149

 

 

.isnumeric 也可甄别 汉字‘二’

12、

test='_123rt'
v=test.isidentifier()       # 判断 标识符 格式是否正确  注意:标识符同字符串规则一样,不能使用数字开头
print(v)

 home88一必发 150

13、

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

home88一必发 151

14、

test='    '
v=test.isspace()        # 判断是否字符串全为空格
print(v)

home88一必发 152

15、

test='Gou long hui'
v=test.istitle()        # 判断是否为标题(标题中每一个首字母都需大写)
print(v)
v=test.title()      # 转换为标题
print(v)

home88一必发 153

16、

test='aeiou'
test1='12345'   #  获得对应关系
v='asidou'
v1=str.maketrans('aeiou','12345')       # 替换功能
new_v=v.translate(v1)
print(new_v)

home88一必发 154

17、

test='aLEx'
v=test.swapcase()       # 大小写转换
print(v)

home88一必发 155

17、

test='username\temail\tpassword\ngoulonghui\tglh020@qq.com\t123\nweiguoquan\tweiguoquan@qq.com\t234'
v=test.expandtabs(20)       # 从开始往后找制表符'\t',20个一组,找到后用空格自动补齐20,可用于制作表格
print(v)

home88一必发 156

 

必背魔法:

1、

test='alexex'
v=test.find('ex')       # 从开始往后找,找到第一个之后,获取其位置
print(v)

 

home88一必发 157

test='alexex'
v=test.rfind('ex',2,5)      # 从右往左找,规定范围在>=2,<5,之间,获取其位置, 注意:无论从左往右还是,从右往左数,都是左边第一个字符 索引为0
print(v)

home88一必发 158

 

2、

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

home88一必发 159

3和4 、

test='ALex'
v1=test.islower()       # 判断字符串是否全为小写
v2=test.lower()         # 将字符串全部转换为小写
v3=test.isupper()       # 判断字符串是否全为大写
v4=test.upper()         # 将字符串全部转换为大写
print(v1,v2,v3,v4)

home88一必发 160

5、

test='  xalex  '
test1='al\te\tx'
# v1=test.lstrip()          # 去除左边空格
# v2=test1.lstrip()         # 去除‘\t’‘\n’
# v3=test.rstrip()          # 去除右边空格
# v4=test1.rstrip()         # 去除‘\t’‘\n’
# v5=test.strip()           # 去除所有空格
# v6=test1.strip()          # 去除‘\t’‘\n’
test2='xalex'
v7=test2.lstrip('xa')       # 去除指定字符
print(v7)


6、

test='testasdsddfg'
v1=test.partition('s')      # 以目标's'分割,找到第一个s后分,只能分割三块
v2=test.rpartition('s')     # 以目标's'分割,从右找 找到第一个s后分,只能分割三块
v3=test.split('s',)         # 以目标's'分割,找到第一个s后分,但是不显示分割字符s
v4=test.rsplit('s')         # 以目标's'分割,从右找到第一个s后分,但是不显示分割字符s
v5=test.split('s',2)        # 以目标's'分割,找到2个s后停止分割,且不显示分割字符s
print(v1)
print(v2)
print(v3)
print(v4)
print(v5)

home88一必发 161

特例:test.splitlines() 
表示根据换行符‘\n’分割      test.splitlines(True) 则展现换行符‘\n’,
test.splitlines(False),则不出示换行符‘\n’。

7、

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

home88一必发 162

 

 

非同常常用法:

1、

test='alex'
v=test[2]           # 据 索引 或 下标 获取字符串中的某个字符
print(v)
v2=test[0:2]        # 索引范围 左开右闭,顾头不顾尾
print(v2)
v3=len(test)        # 判断当前字符串有多少字符组成
print(v3)

home88一必发 163

2、for

test='苟陇辉苟'
index=0
while index<len(test):
    v=test[index]
    print(v)
    index+=1
print('====')

home88一必发 164

使用for语句时:

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

home88一必发 165     一个一个输出

 

字符串一旦创设,不可修改;

比方修改或者拼接,都会促成重复生成字符串;

补充:

range的用法   
扶助创立三番五次的数字,v=range(0,100,5)步长为5

                 v=’alexalexalex’

replace      v=test.replace(‘ex’,’bbb’,2) 
 2为轮换前2个

 

训练题:将用户输入的文字及其对应的目录打印出来。

test=input('请输入:')
v=range(0,len(test))
for item in v:
    print(item,test[item])

home88一必发 166

 

 三、列表list

list
为类,li为经过list类创制的对象,列表里每一个要素通过, 隔开,中括号
括起来;可以修改,删除

方法

1、

 

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

 

li = [1,12,9,'age',['苟陇辉',[19,10],'你'],'alex',True]
print(li[3])            #
print(li[3:5])
li[1] = 120
print(li)
li[1] = [11,22,33,44]
print(li)
li[2:4] = [120,90]
print(li)
del li[1]
print(li)
del li[2:6]
print(li)           # 可通过索引、切片 取值,删除其中的元素

home88一必发 167

 

平等支撑for循环,while 循环

2、in 操作

v = 12 in li

print(v)        True

 

3、

li = [1,12,9,'age',['苟陇辉',['19','10'],'你'],'alex',True]
v = li[4][1][0][1]      # 索引取值一直往里找
print(v)

结果为9
4、
(1)

s = 'asdfghkl'
list(s)             # 转化功能   字符串转化为列表,内部使用的for循环,注意: 数字不可被转化,不可使用for循环
print(list(s))

home88一必发 168

(2)、列表转化字符串

①:列表中既有数字,又有字符串是 要求协调写一个for循环一个一个甩卖:

li=[1,2,3,’alex]

s=”

for item in li

  s=s+str(item)

print(s)

② 只有字符串

li=[‘123′,’alex’]

v=”.join(li)

print(v)

一般方法:

1、

li = ['11','22','33','44']
li.append(5)            # 直接在原值后面追加一个
print(li)
li.append([99,'苟陇辉'])      # 只将一个整体以列表的形式加进去
print(li)
li.extend([99,'苟陇辉'])       # 将每一个元素都加进去
print(li)

home88一必发 169

2、

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

home88一必发 170

3、

li = ['11', '22', '33', '44','22']
v = li.count('22')                  #  计算‘22 ’出现的次数
print(v)

home88一必发 171

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)

5、

li = [11,22,33,22,44]
li.reverse()                        # 将当前列表进行反转
print(li)
li.sort()                           # 排序,从小到大排序
print(li)
li.sort(reverse=True)               # 从大到小排序
print(li)

home88一必发 172

6、删除

li = [11,22,33,22,44]
v = li.pop()                # 默认删除最后一个元素
print(li)                   # 获取删除后的列表
print(v)                    # 获取删除的值
li.pop(1)                   # 删除指定索引的元素
print(li)
print(li.pop(1))

li = [11,22,33,22,44]
li.remove(22)               # 删除指定的元素
print(li)

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

home88一必发 173

 四、元祖  tuple

类:元祖   根据元祖类创设的目的 tu ;     
 #  元祖是对列表的二次加工; 
小括号括起来,最后边加一个逗号“,”;

注:元祖(一级元素)不可被涂改,不能被伸张或者去除; 
 有序的;

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

 常用艺术:

1、索引取值:v = tu[0]

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

3、支持for循环

4、相互转换:s li tu

v = tuple(s)   v = tuple(li)

v = list(tu)     v = ‘_’.join(tu)(
唯有字符串时)

诚如方法:

count  : v = tu.count(33)    获取元素33 
在 tu中出现的次数

index   :   v = tu.index(111)   获取元素
111  在tu中的索引    右边优先

 

五、字典 dict

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

info = {‘k1’:18,

           ‘k2’:true

         
 ‘k3’:[11,22,33,{‘kk1′:’vv1′,’kk2′:’vv2′},’kk3’:(11,22,)]

           ‘k4’:(11,22,33)}

小心: value  但是任意值

             key    列表,字典,不可为key
;bool值  True  默许=1   False  默许=0,倘诺重复是  则不出示

1、字典是无序的

2、取值:据K取值,即据索引取到指定元素
,但不足选择切片(因为字典是无序的)。

3、删除:据K删除      del info
[‘k3’][‘kk1’]

4、支持for循环 

for item in info         ==       for item
in into.keys      默许循环‘k’

  print(item)   

for item in info.values       
循环‘values’

  print(item)

for (k,v) in info.items()     
 循环K,V

  print(k,v)

5.v = dic.get(‘k1′,’111’)   
根据k获取值,key不存在时,可以可指定输入结果 111 
 不指定值时,默许结果为none

   print(v)

6 、v = dic.pop(‘k1’,90)   
 找不到K值时,不报错,可指定 90  结果   
注意:不写k时,默认删除最终一个

      print(dic,v)   其中v 为除去的值 
 

      dic.popitem  随机删除

7、v = dic.setdefault(‘k’,123)   

 
 设置值,若key以存在,则不安装,获取当前k对应的值;
不设有时,设置并收获当前K对应的值

8、dic.uptade({‘k1′:’1234′,’k3′:’3333’}) 
  更新字典,若K以存在,则更新其V,若K不存在,加一个进入。

六、BOOL值

注意:转换为bool值  :  bool()

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

其他均为真。

   总结:

可变:列表,字典

不可变:字符串,数字,元祖     
            验证形式:name = ‘alex’  id(name)  可查看其储存ID

 

做客顺序:①:直接访问:数字

                 
②:顺序访问(即索引):字符串、列表、元祖

                 
③:映射:字典

积存元素个数:

                     
容器类型:列表、元祖、字典

                     
 原子: 数字、字符串

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

概念:①:不一样因素构成

           ②:无序

         
 ③:集合中的元素必须是不足变类型:数字、字符串、元祖

方法:

# 集合:
# s = set('hello')            # 定义一个集合
# print(s)

# s = {1,2,3,4,5,'6'}
# s.add('2')                  # 添加一个元素
# print(s)

# s = {1,2,3,4,5,'6'}
# s.clear()                   # 清空列表
# print(s)

# s = {1,2,3,4,5,'6'}
# s1 = s.copy()                 # 复制
# print(s1)

# s = {1,2,3,4,5,'6'}
# s.pop()                         # 随机删
# print(s)

# s = {1,2,3,4,5,'6'}
# s.remove('6')               # 指定元素删除,找不到时报错
# s1 = s.discard('6')         # 指定元素删除,找不到时不报错

# v = ['aaa','bbb','ccc']
# v1 = ['aaa','bbb','eee']
# s = set(v)
# s1 = set(v1)
# print(s,s1)
# print(s.intersection(s1))   # 交集
# print(s&s1)                 # 交集
#
# print(s.union(s1))          # 并集
# print(s|s1)                 # 并集
#
# print(s.difference(s1))     # 差集
# print(s1.difference(s))     # 差集
#
# print(s.symmetric_difference(s1))   # 交叉补集
# print(s^s1)                         # 交叉补集
#
# s.difference_update(s1)             # 差集之后 将得到的集合赋值给给s (即更新)
# print(s)

# s1 = {1, 2}
# s2 = {1, 2, 3, 4}
# print(s1.issubset(s2))   #    结果为 True   s1是s2的子集
# print(s2.issuperset(s1))  #   True   s2是s1的父集
# s1.update(s2)    # 更新多个值
# s1.add(5)  # 更新一个值
# s1.union(s2)     # 不更新
# print(s1)

# s = set( )        # 定义可变的集合
# s = frozenset()   # 定义不可变的集合

# names = ['alex','glh','alex','wc']          #  简单去重
# s = set(names)
# print(s)
# names = list(s)

八、字符串格式化

 

字符串格式化:
# 一:百分号方式
#  %s 均可接收    %d 只能接收数字类型   %f 浮点数(小数)
# msg = 'i am %s my hobby is %s' %('glh','alex')     # %.2s代表截取字符串的长度为2
# print(msg)

# tpl = 'percent%.2f' %(99.895652)        #2代表保留2位小数
# print(tpl)
# tpl = 'percent%.2f %%'%(99.895652)      # 打印百分比
# print(tpl)
# 
# tpl = 'i am %(pp).2f' %{'pp': 123.456}   #  后边为字典
# print(tpl)
# 
# msg = 'i am %(name)+60s %(age)d'%{'name': 'glh','age': 23}      # +号表示右对齐并补齐60位
# print(msg)
# msg = 'i am \033[46;1m%(name)+60s\033[0m my hobby is alex ' %{'name': 'glh'}        # 加颜色
# print(msg)
# 
# print('root','x','x','o',sep=':')  # 分别得到结果 后拼接成一条记录    结果为  root:x:x:o
# 
# 二 format 字符串格式化

# tpl = 'i am {},age{},{}'.format('glh','23','alex')
# print(tpl)
# tpl = 'i am {2},age{1},{0}'.format('glh','23',['alex',23])      # 相当于按照后面后面元祖索引取值
# print(tpl)

# #  .format('seven',18) == .format(*['seven',18])
# #  .format('seven',18) == .format(**{'seven',18})

# tpl = 'numbers: {:b},{:o},{:d},{:x},{:X},{:%}'.format(15,15,15,15,15,15.89632)
# print(tpl)
# # 结果为numbers: 1111,17,15,f,F,1589.632000%   上述分别代表打印二进制 八进制 十进制 十六进制小写 十六进制大写 转换为百分数,默认保留6位

         

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

        

 

 

 

 

发表评论

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

网站地图xml地图