操作系统 159

python基本数据类型之,Python运算符及基本数据类型

一、列表—-list

1、算数运算符:

一、数据类型

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

         
列表是有序的,列表元素可以被修改

+   –  *  /   **    %  //  

1、整数(int类)

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

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

num=9%2

bit_length()

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

 

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

 操作系统 1

1、列表格式:

print(num)

2、布尔型(bool类)

True 1

False 0

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

  中括号括起来,

num=9%2
print(num)


num=9//2
print(num )

3、字符串(str类)

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

  逗号分隔每个元素,

2、成员运算

3.1 字符串提供的功能

3.1.1 upper()

变大写

 操作系统 2

3.1.2 lower()

变小写

 操作系统 3

3.1.3 capitalize()

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

 操作系统 4

3.1.4 strip()

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

 操作系统 5

示例:

 操作系统 6

3.1.5 lstrip()

去除左边空格

 操作系统 7

3.1.6 rstrip()

去除右边空格

 操作系统 8

3.1.7 replace()

替换

 操作系统 9

操作系统 10

 

 操作系统 11

操作系统 12

3.1.8 split()

分割

 操作系统 13

操作系统 14

操作系统 15

操作系统 16

3.1.9 isdecimal()

判断当前字符串中是否全部都是数字

 操作系统 17

示例:

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

 操作系统 18

 

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

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

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

3.1.10 join()

连接列表的元素

 操作系统 19

  “集合“,”内部可以放置任何东西

in             not in   判断某个东西是否在某个东西中包含。

3.1.11 endswith()、startswith()

print(name.endswith(‘SB’))#判断是否以’SB’结尾 print(name.startswith(‘alex’))#判断是否以’alex’开头

 操作系统 20

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

3、逻辑运算

3.1.12 encode(‘utf-8或gbk’)

把字符串转化成字节

 操作系统 21

操作系统 22

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

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

3.1.13 find()、index()

find()

在字符串中查找,找不到返回-1

 操作系统 23

 

index()

在字符串中查找,找不到报错

 操作系统 24

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

# ” 空字符为假

3.1.14 format()

格式化字符串

(1)

 操作系统 25

(2)

 操作系统 26

(3)

 操作系统 27

(4)

 操作系统 28

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

# ‘   ‘  只要里面有东西 就为真

3.1.15 casefole()

字符串变小写,包含小语种,lower()只能改变英文

 操作系统 29

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

#  0    假

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

center():两边补字符

ljust():右边补字符

rjust():左边补字符

 操作系统 30

5、列表元素可以进行修改

# 其他  真

3.1.17 count()

计算个数

 操作系统 31

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

  ‘转换bool值     

3.1.18 expandtabs()

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

 操作系统 32

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

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

a=123

3.1.19 index()

列表字符的索引

 操作系统 33

6、删除

b=bool(a )’

3.1.20 isdigit()

判断字符串的内容是否是纯数字

 操作系统 34

  索引删除: 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()

判断字符串的内容是否是纯字母

 操作系统 35

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

4、赋值运算

3.1.22 isspace()

 操作系统 36

7、支持 in 操作

count=1

3.2 公共功能

3.2.1 len()

计算当前字符串长度

 操作系统 37

 

3.2.2 索引、下标

#      –  单个值:v[0]

#      –  多个值:v[起始位置:结束位置]

#      –  多个值:v[起始位置:结束位置:步长]

#      PS: -1表示最后

 操作系统 38

操作系统 39

操作系统 40

操作系统 41

示例:

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

操作系统 42

操作系统 43

 

  v = ‘alex’ in li         print(li)

count=count+1  即  count+=1

4、int-bool-str转换

int    89  90

bool   True False

str  ‘sdf’ ‘7’

8、嵌套列表查询方式

count=count%1 即 count%=1

4.1 str–>int

示例:

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

 操作系统 44

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

5、比较运算

4.2 str–>bool

空值字符串–False

其他–True

 操作系统 45

操作系统 46

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

a= 1>5

4.3 int–>str

str(int)

 操作系统 47

9、字符串转换成列表

print(a)

4.4 int–>bool

0–False

其他–True

 操作系统 48

  s=’abcdefg’

结果为 false

4.5 bool–>str

str(bool)

  li = list(s)

 

4.6 bool–>int

True–1

False–0

 操作系统 49

操作系统 50

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

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

  如果列表中即有数字又有字符串,需要自己写一个for循环

 一、整形  int   

5.1 list类中提供的功能

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

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

5.1.1 append()

在列表尾部追加一个值[修改本身值]

 操作系统 51

示例:

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

 操作系统 52

    s=’ ‘

魔法  

5.1.2 insert()

在指定位置插入数据

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

 操作系统 53

    for i in li :

1、转换功能

5.1.3 reverse()

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

 操作系统 54

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

删除

 操作系统 55

pop()不指定位置默认删除最后一个,返回删除元素的值

 操作系统 56

    print(s)

操作系统 57

5.1.5 index()

找参数的位置

 操作系统 58

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

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

5.1.6 clear()

清空列表

 操作系统 59

  li = [‘xiaozhang’, ‘xiaowang’]

操作系统 60

5.1.7 sort()

排序

按ASCII码排序

 操作系统 61

操作系统 62

   v = ‘ ‘.join(li)

2、

5.1.8 extend()

合并

 操作系统 63

   print (v)

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

5.1.9 copy()

复制、浅拷贝

 操作系统 64

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

现在的需求是要输出的names2与第一行names定义的相同

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

 操作系统 65

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

 操作系统 66

列表的特性

 操作系统 67

与字符串或数字不同

 操作系统 68

深拷贝

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

 操作系统 69

简述深浅拷贝

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

#如果拷贝多层列表时

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

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

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

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

操作系统 70

5.2 公共功能

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

计算列表长度

 操作系统 71

 二、元祖
tuple     

魔法 

5.2.2 索引

 操作系统 72

  元素不可被修改,且元素不能被增加或者删除,但是可以被查看

1、

5.2.3 循环

for

 操作系统 73

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

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

5.2.4 替换

 操作系统 74

        按照惯例一般在末尾价格逗号来识别

操作系统 75

5.2.5 删除

del

 操作系统 76

操作系统 77

  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)

 操作系统 78

2、可以进行for循环(可迭代对象)

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

5.3 删除补充

删除列表元素时,会影响列表长度,从而使得索引取值时,容易出现错误。

 操作系统 79

解决方法:

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

 操作系统 80

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

 操作系统 81

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

 操作系统 82

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

操作系统 83

6、元组(tuple类)

不可变的容器

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

4、extend扩展,在元祖中同样适用

注意:

6.1 公共功能

5、元祖是有序的

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

6.1.1 len()

 操作系统 84

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

操作系统 85

6.1.2 索引

 操作系统 86

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

3、

6.1.3 循环

for

 操作系统 87

三、字典 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)

 操作系统 88

  字典的value可以是任何值

操作系统 89

7、字典(dict类)

 

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

7.1 dict类中提供的功能

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

4、

7.1.1 get()

根据key获取对应的值,key不存在默认取None

 操作系统 90

  布尔值,列表、字典不能作为字典的key

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

7.1.2 keys()

 操作系统 91

1、查找字典内容

 操作系统 92

7.1.3 values()

 操作系统 93

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

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

7.1.4 items()

 操作系统 94

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

操作系统 95

7.1.5 update()

合并两个字典,如果有重复键则合并值,没有重复的键则添加值

 操作系统 96

操作系统 97

3、for循环

5、

7.2 公共功能

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

 操作系统 98

 

操作系统 99

7.2.2 获取

 操作系统 100

6、

7.2.3 设置

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

 操作系统 101

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

7.2.4 删除

del

 操作系统 102

操作系统 103

7.2.5 循环

for

 操作系统 104

注意:找不到时 结果为-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]
}

 

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

 操作系统 105

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

7.4 删除补充

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

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

 操作系统 106

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

错误:

 操作系统 107

正确:

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

 操作系统 108

操作系统 109    程序报错

8、字节(bytes类)

bytes

一般网络传输和硬盘存储使用bytes类型

8、

8.1表现形式

name = b’alex’

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

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

 操作系统 110

操作系统 111

9、浮点数(float类)

#小数

    #有限小数

    #python基本数据类型之,Python运算符及基本数据类型。无限循环小数 3.33333 、4.404404

#无限不循环小数  派

#浮点数

    #有限小数

#无限循环小数 3.33333 、4.404404

 操作系统 112

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

10、复数(complex类)

#复数 = #实数 #虚数

#复数 = 实部 + 虚部

#a+bj

 操作系统 113

操作系统 114

11、集合(set类)

9、

11.1 性质

集合的元素无重复,可以做快速去重的方法

集合是可变数据类型

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

集合内部元素时不可变数据类型

集合内部不能嵌套集合

 

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

11.2 功能

操作系统 115

11.2.1 add()

添加

 操作系统 116

10、

11.2.2 difference()、difference_update()

差集

difference()

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

 操作系统 117

difference_update()

直接修改原集合

 操作系统 118

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

11.2.3 symmetric_difference()、symmetric_difference_update()

排除两个集合同时存在的值

symmetric_difference()

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

symmetric_difference_update()

直接修改原集合

 操作系统 119

操作系统 120

11.2.4 dicard()

在集合中删除制定值

 操作系统 121

11、

11.2.5 intersection()、intersection_update()

求交集

intersection()

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

intersection_update()

直接修改原集合

 操作系统 122

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

11.2.6 union()

求并集

 操作系统 123

操作系统 124

11.2.7 isdisjoint()

判断是否无交集

 操作系统 125

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

11.2.8 issubset()、issuperset()

issubset() 是否是子集

issuperset()是否是父集

 操作系统 126

操作系统 127

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

删除集合的元素

pop()

删除元素并返回该元素

 操作系统 128

remove()

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

 操作系统 129

discard()

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

 操作系统 130

操作系统 , 

11.2.10 update()

更新

 操作系统 131

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

11.2.11 for循环

 操作系统 132

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

11.2.12 len()

长度

 操作系统 133

 操作系统 134

11.3 各类型转换

 操作系统 135

 

 

.isnumeric 也可识别 汉字‘二’

12、

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

 操作系统 136

13、

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

操作系统 137

14、

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

操作系统 138

15、

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

操作系统 139

16、

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

操作系统 140

17、

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

操作系统 141

17、

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

操作系统 142

 

必背魔法:

1、

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

 

操作系统 143

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

操作系统 144

 

2、

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

操作系统 145

3和4 、

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

操作系统 146

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)

操作系统 147

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

7、

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

操作系统 148

 

 

特殊用法:

1、

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

操作系统 149

2、for

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

操作系统 150

使用for语句时:

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

操作系统 151     一个一个输出

 

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

一旦修改或者拼接,都会造成重新生成字符串;

补充:

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

操作系统 152

 

 三、列表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)           # 可通过索引、切片 取值,删除其中的元素

操作系统 153

 

同样支持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))

操作系统 154

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

操作系统 155

2、

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

操作系统 156

3、

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

操作系统 157

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)

操作系统 158

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)

操作系统 159

 四、元祖  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位