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

  若列表中的成分唯有字符串,直接用字符串join方法

 

4.4 int–>bool

0–False

其他–True

 网赌十大信誉的平台 1

伍 、列表成分能够开始展览改动

a=123

7.1.3 values()

 网赌十大信誉的平台 2

    print(s)

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

8.1表现形式

name = b’alex’

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

         
列表是不变的,列表元素能够被涂改

16、

11.2.1 add()

添加

 网赌十大信誉的平台 3

    for i in li :

6 、v = dic.pop(‘k1’,90)   
 找不到K值时,不报错,可钦定 90  结果   
注意:不写k时,暗中同意删除最后四个

9、浮点数(float类)

#小数

    #有限小数

    #无限循环小数 3.33333 、4.404404

#无限不循环小数  派

#浮点数

    #有限小数

#极端循环小数 3.33333 、4.404404

 网赌十大信誉的平台 4

② 、能够开始展览for循环(可迭代对象)

 

11.2.12 len()

长度

 网赌十大信誉的平台 5

 

 

7.1 dict类中提供的职能

③ 、因为是可迭代对象:字符串、列表、元祖能够并行转换

注:元祖(一流元素)不可被修改,无法被增添照旧去除; 
 有序的;

11.2.6 union()

求并集

 网赌十大信誉的平台 6

⑧ 、嵌套列表查询办法

网赌十大信誉的平台,  s=s+str(item)

5.2.4 替换

 网赌十大信誉的平台 7

      s=s+str(i)

网赌十大信誉的平台 8

5.1.6 clear()

清空驶列车表

 网赌十大信誉的平台 9

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

网赌十大信誉的平台 10    程序报错

11.3 种种型转换

 网赌十大信誉的平台 11

 

一 、列表格式:

概念:①:区别因素结合

7.2.5 循环

for

 网赌十大信誉的平台 12

② 、列表中能够嵌套任何类型

 

11.2.4 dicard()

在集合中删去制定值

 网赌十大信誉的平台 13

10、列表转换到字符串

3、支持for循环

① 、数据类型

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

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

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

5.2.2 索引

 网赌十大信誉的平台 14

  中括号括起来,

3和4 、

4.1 str–>int

示例:

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

 网赌十大信誉的平台 15

一 、查找字典内容

 

6.1.2 索引

 网赌十大信誉的平台 16

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

网赌十大信誉的平台 17

1、整数(int类)

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

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

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

2、布尔型(bool类)

True 1

False 0

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

  print(li)

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

6.1.1 len()

 网赌十大信誉的平台 18

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

range的用法   
援助创立接二连三的数字,v=range(0,100,5)步长为5

7.1.2 keys()

 网赌十大信誉的平台 19

=====================list类中提供的措施===================

专注:找不到时 结果为-1

3.1.21 isalpha()

判断字符串的剧情是或不是是纯字母

 网赌十大信誉的平台 20

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

   总结:

10、复数(complex类)

#复数 = #实数 #虚数

#复数 = 实部 + 虚部

#a+bj

 网赌十大信誉的平台 21

三、字典 dict

 

5.1.1 append()

在列表尾部扩张八个值[修改自个儿值]

 网赌十大信誉的平台 22

示例:

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

 网赌十大信誉的平台 23

6、删除

①:列表中既有数字,又有字符串是 要求团结写一个for循环2个1个处理:

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)

 网赌十大信誉的平台 24

   v = ‘ ‘.join(li)

                 
③:映射:字典

5.1.7 sort()

排序

按ASCII码排序

 网赌十大信誉的平台 25

网赌十大信誉的平台 26

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

 

5.1.3 reverse()

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

 网赌十大信誉的平台 27

 

网赌十大信誉的平台 28

5.1.8 extend()

合并

 网赌十大信誉的平台 29

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)   

结果为 false

3.1.20 isdigit()

认清字符串的剧情是或不是是纯数字

 网赌十大信誉的平台 30

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

 

5.1.5 index()

找参数的地方

 网赌十大信誉的平台 31

  li = [‘xiaozhang’, ‘xiaowang’]

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

7.1.5 update()

联合三个字典,固然有重复键则合并值,没有再次的键则添加值

 网赌十大信誉的平台 32

网赌十大信誉的平台 33

  字典的value可以是此外值

   print(v)

7.2.3 设置

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

 网赌十大信誉的平台 34

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

网赌十大信誉的平台 35

11.1 性质

聚拢的成分无重复,能够做急迅去重的方法

会面是可变数据类型

聚集内部无法加可变数据类型,如列表,列表

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

集合内部不可能嵌套集合

 

        依据常规一般在终极价格逗号来鉴定区别

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

7.1.4 items()

 网赌十大信誉的平台 36

  v = ‘alex’ in li         print(li)

演习题:将用户输入的文字及其相应的目录打字与印刷出来。

3.1.11 endswith()、startswith()

print(name.endswith(‘SB’))#判定是不是以’SB’结尾 print(name.startswith(‘alex’))#判断是不是以’alex’开端

 网赌十大信誉的平台 37

  逗号分隔每一个成分,

 四、元祖  tuple

11.2.5 intersection()、intersection_update()

求交集

intersection()

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

intersection_update()

直接改动原集合

 网赌十大信誉的平台 38

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

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

3、字符串(str类)

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

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

 

3.1 字符串提供的成效

3.1.1 upper()

变大写

 网赌十大信誉的平台 39

3.1.2 lower()

变小写

 网赌十大信誉的平台 40

3.1.3 capitalize()

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

 网赌十大信誉的平台 41

3.1.4 strip()

剔除首尾空格、换行、制表符、制定的始末

 网赌十大信誉的平台 42

示例:

 网赌十大信誉的平台 43

3.1.5 lstrip()

除去左边空格

 网赌十大信誉的平台 44

3.1.6 rstrip()

删去左侧空格

 网赌十大信誉的平台 45

3.1.7 replace()

替换

 网赌十大信誉的平台 46

网赌十大信誉的平台 47

 

 网赌十大信誉的平台 48

网赌十大信誉的平台 49

3.1.8 split()

分割

 网赌十大信誉的平台 50

网赌十大信誉的平台 51

网赌十大信誉的平台 52

网赌十大信誉的平台 53

3.1.9 isdecimal()

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

 网赌十大信誉的平台 54

示例:

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

 网赌十大信誉的平台 55

 

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

 

5.1.4 remove()、del、pop()

删除

 网赌十大信誉的平台 56

pop()不点名地方暗中同意删除最终一个,重临删除成分的值

 网赌十大信誉的平台 57

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

六、BOOL值

6.1.3 循环

for

 网赌十大信誉的平台 58

一、列表—-list

宗旨数据类型

11.2 功能

四 、extend扩大,在元祖中同样适用

 

4、int-bool-str转换

int    89  90

bool   True False

str  ‘sdf’ ‘7’

⑤ 、元祖的一级成分不可被修改,元祖中嵌套的列表可以被改动

网赌十大信誉的平台 59

11.2.10 update()

更新

 网赌十大信誉的平台 60

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

           ②:无序

11.2.3 symmetric_difference()、symmetric_difference_update()

排除三个集聚同时设有的值

symmetric_difference()

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

symmetric_difference_update()

直白修改原集合

 网赌十大信誉的平台 61

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

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

 网赌十大信誉的平台 62

7、支持 in 操作

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

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)

 网赌十大信誉的平台 63

   print (v)

注意:

3.1.22 isspace()

 网赌十大信誉的平台 64

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

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

7、字典(dict类)

  ① 、可由此索引取值,切片取值

网赌十大信誉的平台 65

5.2.1 len()

计量列表长度

 网赌十大信誉的平台 66

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

 

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

 网赌十大信誉的平台 67

  li = list(s)

瞩目: value  不过任意值

7.2.2 获取

 网赌十大信誉的平台 68

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

 

3.2 公共职能

3.2.1 len()

测算当前字符串长度

 网赌十大信誉的平台 69

 

3.2.2 索引、下标

#      –  单个值:v[0]

#      –  多个值:v[初阶地方:结束地方]

#      –  多个值:v[胚胎地点:结束地方:步长]

#      PS: -1表示最后

 网赌十大信誉的平台 70

网赌十大信誉的平台 71

网赌十大信誉的平台 72

网赌十大信誉的平台 73

示例:

*# 题: 列出v = “ASCII第1遍以规范标准的型态发”
# v = “ASCII第2回以正规化标准的型态发”
# 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 循环 

网赌十大信誉的平台 74

网赌十大信誉的平台 75

 

  s=’abcdefg’

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

4.3 int–>str

str(int)

 网赌十大信誉的平台 76

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

count=count%1 即 count%=1

4.6 bool–>int

True–1

False–0

 网赌十大信誉的平台 77

网赌十大信誉的平台 78

    s=’ ‘

网赌十大信誉的平台 79

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

center():两边补字符

ljust():左边补字符

rjust():左边补字符

 网赌十大信誉的平台 80

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

 网赌十大信誉的平台 81

6.1 公共职能

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

网赌十大信誉的平台 82

3.1.13 find()、index()

find()

在字符串中寻找,找不到重返-1

 网赌十大信誉的平台 83

 

index()

在字符串中摸索,找不到报错

 网赌十大信誉的平台 84

伍 、元祖是百无一成反类犬的

肆 、赋值运算

7.4 删除补充

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

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

 网赌十大信誉的平台 85

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

错误:

 网赌十大信誉的平台 86

正确:

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

 网赌十大信誉的平台 87

玖 、字符串转换来列表

 

5.1.9 copy()

复制、浅拷贝

 网赌十大信誉的平台 88

有3个本性:浅copy,只copy第2层

今昔的须求是要出口的names2与第2行names定义的等同

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

 网赌十大信誉的平台 89

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

 网赌十大信誉的平台 90

列表的特色

 网赌十大信誉的平台 91

与字符串或数字差异

 网赌十大信誉的平台 92

深拷贝

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

 网赌十大信誉的平台 93

简述深浅拷贝

#一经拷贝单层列表时,深浅拷贝都把原列表拷贝到了一个新的内部存款和储蓄器地址,所以原列表被修改新列表都不会被改动

#假使拷贝多层列表时

    #浅拷贝只将原列表的首先层拷贝到了新的内部存款和储蓄器地址,新列表二层及以内的照样指向原列表的内部存储器地址,所以原列表被修改,新列表的

    #先是层不会改变,二层及以内的会随着新列表修改

    #深拷贝是将原列表的持有都拷贝到了新的内部存款和储蓄器地址,原列表被涂改,新列表不会改变

3、for循环

print(num)

11.2.11 for循环

 网赌十大信誉的平台 94

  成分不可被修改,且成分不可能被扩展恐怕去除,不过足以被翻开

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

11.2.2 difference()、difference_update()

差集

difference()

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

 网赌十大信誉的平台 95

difference_update()

间接修改原集合

 网赌十大信誉的平台 96

 二、元祖
tuple     

 

3.1.10 join()

连日来列表的元素

 网赌十大信誉的平台 97

③ 、能够透过索引取值,  恐怕切片取值(切片取值的结果也是列表)

15、

8、字节(bytes类)

bytes

貌似互连网传输和硬盘存款和储蓄使用bytes类型

#  0    假

11、集合(set类)

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)

4.7 示例

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

for item in li

4.2 str–>bool

空值字符串–False

其他–True

 网赌十大信誉的平台 98

网赌十大信誉的平台 99

li=[‘123′,’alex’]

11.2.7 isdisjoint()

判断是不是无交集

 网赌十大信誉的平台 100

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

4.5 bool–>str

str(bool)

方法

3.1.19 index()

列表字符的目录

 网赌十大信誉的平台 101

网赌十大信誉的平台 102

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

除去集合的因素

pop()

删除成分并赶回该因素

 网赌十大信誉的平台 103

remove()

去除,要是成分不存在会报错

 网赌十大信誉的平台 104

discard()

删去,借使成分不存在不会报错

 网赌十大信誉的平台 105

b=bool(a )’

5.2.3 循环

for

 网赌十大信誉的平台 106

  print(item)

5.2.5 删除

del

 网赌十大信誉的平台 107

网赌十大信誉的平台 108

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

3.1.14 format()

格式化字符串

(1)

 网赌十大信誉的平台 109

(2)

 网赌十大信誉的平台 110

(3)

 网赌十大信誉的平台 111

(4)

 网赌十大信誉的平台 112

貌似方法:

7.2.4 删除

del

 网赌十大信誉的平台 113

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

3.1.18 expandtabs()

能够联手换行符制表符使用,固定字符间隔长度

 网赌十大信誉的平台 114

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

网赌十大信誉的平台 115

5.3 删除补充

删去列表成分时,会潜移默化列表长度,从而使得索引取值时,简单并发谬误。

 网赌十大信誉的平台 116

缓解格局:

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

 网赌十大信誉的平台 117

# 消除方案二: 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)

 网赌十大信誉的平台 118

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

 网赌十大信誉的平台 119

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

7.2 公共职能

 

11.2.8 issubset()、issuperset()

issubset() 是或不是是子集

issuperset()是或不是是父集

 网赌十大信誉的平台 120

(2)、列表转化字符串

3.1.17 count()

测算个数

 网赌十大信誉的平台 121

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

5.1 list类中提供的功用

网赌十大信誉的平台 122

6、元组(tuple类)

不可变的器皿

唯有3个成分时,一定加逗号(1,)

三 、逻辑运算

7.2.1 len()

 网赌十大信誉的平台 123

网赌十大信誉的平台 124

5.1.2 insert()

在钦定地方插入数据

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

 网赌十大信誉的平台 125

 

5.2 公共职能

② 、成员运算

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

 

list
为类,li为经过list类创设的对象,列表里每1个因素通过, 隔离,中括号
括起来;能够修改,删除

3.1.15 casefole()

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

 网赌十大信誉的平台 126

④ 、相互转换:s li tu

3.1.12 encode(‘utf-8或gbk’)

把字符串转化成字节

 网赌十大信誉的平台 127

网赌十大信誉的平台 128

 

7.1.1 get()

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

 网赌十大信誉的平台 129

网赌十大信誉的平台 130

5、列表(list类)

可变的容器,自己是生成的

 

bit_length()

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

 

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

 网赌十大信誉的平台 131

.isnumeric 也可识别 汉字‘二’

                 v=’alexalexalex’

网赌十大信誉的平台 132

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

魔法 

 

for item in info.values       
循环‘values’

10、

 网赌十大信誉的平台 133

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

 

for item in info         ==       for item
in into.keys      暗中同意循环‘k’

17、

 三、列表list

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

in             not in   判断某些东西是还是不是在某些东西中隐含。

9、

# 其他  真

网赌十大信誉的平台 134

 

 一、整形  int   

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

网赌十大信誉的平台 135

      dic.popitem  随机删除

 

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

网赌十大信誉的平台 136

print(v)

 

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

test='alex'
v=test.endswith('ex')      #  字符串以什么结尾 
print(v)                   #  v=test.startswith('a') 表示字符串以什么开头   

 

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

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

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

网赌十大信誉的平台 137

  ‘转换bool值     

index   :   v = tu.index(111)   获取成分111  在tu中的索引    左侧优先

 

网赌十大信誉的平台 138

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

网赌十大信誉的平台 139

 

五、字典 dict

 

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

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

 

2、

1、

a= 1>5

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

1、

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)

 

 

 

1、

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

一致帮忙for循环,while 循环

count=count+1  即  count+=1

网赌十大信誉的平台 140

字符串一旦成立,不可修改;

网赌十大信誉的平台 141

 

2、in 操作

12、

 

壹 、字典是严节的

6、

 

# ” 空字符为假

诚如方法:

特殊用法:

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

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

 

num=9%2
print(num)


num=9//2
print(num )

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

可变:列表,字典

网赌十大信誉的平台 142

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

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

使用for语句时:

魔法  

      print(dic,v)   在那之中v 为除去的值 
 

2、

test='aLex'
v=test.center(20,'*')       # 表示  设置宽度,并将内容居中,其中20代表总长度,'*'代表空白处的未知填充,只能有一个字符,可有可无
print(v)
test='苟陇辉苟'
index=0
while index<len(test):
    v=test[index]
    print(v)
    index+=1
print('====')
test='AleX'
v=test.lower()          #也表所有字母变小写,但是特殊字符表示不了。而capitalize()则对于很多未知的对应关系也可以表示
print(v)

网赌十大信誉的平台 143

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

网赌十大信誉的平台 144

print(v)        True

 常用艺术:

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

 

注:在Python3中,无论数字多大,都属于int类型;在Python第22中学,数字变大,抢先一定限制则称为long型;

17、

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

1、

二 、取值:据K取值,即据索引取到内定成分,但不可动用切片(因为字典是严节的)。

 

 

5.v = dic.get(‘k1′,’111’)   
依照k获取值,key不存在时,能够可钦定输入结果 111 
 不钦定值时,默许结果为none

网赌十大信誉的平台 145

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

网赌十大信誉的平台 146

  print(k,v)

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

4、

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

 

count=1

4、支持for循环 

+   –  *  /   **    %  //  

网赌十大信誉的平台 147

 

5、

① 、算数运算符:

print(s)

count  : v = tu.count(33)    获取成分33 
在 tu中冒出的次数

        

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

网赌十大信誉的平台 148

捌 、字符串格式化

 

字符串格式化:
# 一:百分号方式
#  %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位
test='\totijd\n'
v=test.isprintable()        # 判断是否存在不可见的(如\n、\t) ,或运行结果不可显示的字符  
print(v)

2、

补充:

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

 

3、

 

 

3、

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

二、字符型

伍 、相比运算

2、for

test='124'
v=test.isdecimal()      # 判断字符串是否只包含数字
print(v)
test='alex'
v=test.capitalize()         #表示首字母大写
print(v)

2、

 

 

储存成分个数:

走访顺序:①:直接待上访问:数字

num=9%2

                     
 原子: 数字、字符串

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

s=”

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

 

必背魔法:

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

 

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

user='alex'
pwd=123
v=user=='alex' and pwd==124 or user=='ales'and pwd=='123' print(v)
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)           # 可通过索引、切片 取值,删除其中的元素

网赌十大信誉的平台 149

1、

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

 

 
 设置值,若key以存在,则不设置,获取当前k对应的值;
不存在时,设置并得到当前K对应的值

  print(item)   

# ‘   ‘  只要在那之中有东西 就为真

 

网赌十大信誉的平台 150     三个一个出口

网赌十大信誉的平台 151

 网赌十大信誉的平台 152

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

 

方法:

# 集合:
# 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)

① 、转换职能

网赌十大信誉的平台 153

7、

v=”.join(li)

网赌十大信誉的平台 154

5、

 

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)
test='tuys'
v=test.isalpha()        # 判断字符串是否只包含字母 汉字
print(v)

         

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

5、

网赌十大信誉的平台 155

网赌十大信誉的平台 156

网赌十大信誉的平台 157

 

8、

类:元祖   依据元祖类成立的目的 tu ;     
 #  元祖是对列表的二遍加工; 
小括号括起来,最前面加三个逗号“,”;

 

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

网赌十大信誉的平台 158

14、

6、删除

假定修改或然拼接,都会招致重复生成字符串;

print(a)

7、

13、

 

其余均为真。

test='username\temail\tpassword\ngoulonghui\tglh020@qq.com\t123\nweiguoquan\tweiguoquan@qq.com\t234'
v=test.expandtabs(20)       # 从开始往后找制表符'\t',20个一组,找到后用空格自动补齐20,可用于制作表格
print(v)
test='苟陇辉五六七八九'
v='_'.join(test)        # 将字符串中的每一个元素按照指定分隔符拼接。 注意    .join
print(v)

 

 

11、

4、

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

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

 

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

 

 

 

info = {‘k1’:18,

             key    列表,字典,不可为key
;bool值  True  默许=1   False  私下认可=0,固然重复是  则不出示

 

 

           ‘k2’:true

v = 12 in li

② 唯有字符串

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

 if '苟'not in name:
    print('ok')
else:
   print('error')
a='123'
print(type(a),a)     # type 查看类型 
b=int(a)             # 将字符串'123',转换为数字123
print(type(b),b)

网赌十大信誉的平台 159

 

Post Author: admin

发表评论

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