python_04 基本数据类型、数字、字符串、列表、元组、字典

基本数据类型

所有的方法(函数)都带括号，且括号内没带等号的参数需传给它一个值，带等号的参数相当于有默认值

1.数字 int

在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

1.int

　　将字符串转换为数字

　　

a="123"
b=int(a)
print(type(a),a)
print(type(b),b)



》》<class 'str'> 123
》》<class 'int'> 123

################################

num="a"
v=int(num,base=16)#base=16代表转换为16进制，16进制中a=10，b=11
print(v)

》》10

#####################
age=3
r=age.bit_length()#该方法表示当前数字的二进制，至少用n位表示
print(r)

》》2

type()方法返回括号内变量的数据类型

 

2.字符串 str

“hello world”  

a="123"
b=int(a)
print(type(a),a)
print(type(b),b)

》》<class 'str'> 123
》》<class 'int'> 123


#####################
num="a"
v=int(num,base=16)#base=16代表转换为16进制，16进制中a=10，b=11
print(v)

》》10


#####################
age=3
r=age.bit_length()#该方法表示当前数字的二进制，至少用n位表示
print(r)

》》2


#####################
test="alex"
v=test.capitalize()#该方法表示将首字母大写
print(v)

》》Alex


####################
#这两个方法都是将字符串所有变小写，casefold()更牛逼
test1="ALEX"
v1=test.casefold()
v2=test.lower()
print(v1,v2)

>>alex alex


###################
#这个方法相当于设置宽度，并将内容居中，20代表总长，‘%’代表填充物

v3=test.center(20,'%')
print(v3)

>>%%%%%%%%alex%%%%%%%%

##################
#这个方法是计算当前字符串中寻找子序列个数
test4="dasdfgrtert"
v4=test4.count('d',2,60)#‘d’为寻找目标，2和60表示从第2位开始，第60位结束
print(v4)


>>1

#############################

#以什么结尾
#以什么开头
test5="alex"
v5=test5.endswith('s')
v6=test5.startswith('a')
print(v5)

》》False
》》True

################################

#这个方法表示从开始往后找，找到第一个之后，获取其位置
test6="alexalex"
v6=test6.find('ex',5,7)#返回-1则没找到，5，7表示[5,7)的前开后闭的区间中找
print(v6)

》》6

##############################

#格式化，将字符串中的占位符替换为指定的值
test7='i am {name}，{age}'
print(test7)
v7=test7.format(name='alex',age=13)
print(v7)

》》i am {name}，{age}
》》i am alex，13

test8='i am {0}，{1}'
print(test8)
v8=test8.format('alex',13)
print(v8)

》》i am {0}，{1}
》》i am alex，13

#格式化，传入的值{"name":'alsss',"age":19}，相当于字典，"name"和"age"为键
v9=test7.format_map({"name":'alsss',"age":19})
print(v9)

》》i am alsss，19

########################

#判断字符串中是否只包含字母和数字
test10="asfer454r"
v10=test10.isalnum()
print(v10)

》》True

#expandtabs()相当于断句，
test="12345678\t9"
v=test.expandtabs(6)#6表示6个字符串为一句，\t表示空格,若出现\t则用空格补齐6个字符串
print(v,len(v))#len()表示字符串长度


》》12345678    9 13

test1="name\tage\tgender\nManuel\t25\tmale\nApril\t25\tfemale\n"
v1=test1.expandtabs(10)
print(v1)

》》
name      age       gender
Manuel    25        male
April     25        female

####################################

#isalpha()判断当前字符串是否是字母
#isdecimal()和isdigit()（更牛）和isnumeric()(最牛)判断当前字符串是否是数字
test2="rggds"
v2=test2.isalpha()
v3=test2.isdecimal()
v4=test2.isdigit()
v5=test2.isnumeric()
print(v2,v3,v4)

》》True False False False


###############################

#是否存在不可显示的字符

#\t   制表符
#\n   换行
test6="wertwet\twe"
v6=test6.isprintable()
print(v6)

》》False

isspace()#判断字符串内是否全是空格

istitle()#判断字符串是否是标题（所有单词首字母大写）

title()将输入转换为标题的格式

#jion()将字符串中的每一个元素按照指定分隔符进行拼接
test7="你是风儿我是沙"
t='_'
v7=t.join(test7)
print(v7)

》》你_是_风_儿_我_是_沙

ljust()、rjust()与center()类似，区别是将字符串放左边（右边），填充字符串放右边（左边）

islower()、isupper()判断字符串是否为小写、大写

lower()、upper()将字符串变成小写、大写

strip()、lstrip()、rstrip()去掉字符串所有、左边、右边的空格或换行符，括号内为去掉的参数（且参数子序列也可），默认为空格

#maketrans()建立对应关系，translate()利用对应关系替换
v8="sssdawrwq"
m=str.maketrans("sda","123")
v9=v8.translate(m)
print(v9)

》》11123wrwq

#以下方法都是分割
test10="twqedafsdwsewq"
m1=test10.partition('e')#只能将字符串分割成3份，遇到的第一个‘e’就分割，且保留‘e’
m2=test10.rpartition('e')#同上，但是是从右往左
m3=test10.split('e')#不保留‘e’，默认全部分割，再传个参数可以指定分割次数
m4=test10.rsplit('e',1)#同上，从右往左
print(m1)
print(m2)
print(m3)
print(m4)

》》('twq', 'e', 'dafsdwsewq')
》》('twqedafsdws', 'e', 'wq')
》》['twq', 'dafsdws', 'wq']
》》['twqedafsdws', 'wq']
#正则表达式中可以设置是否想要分割的元素，相当于上面两种方法的合集

#这个方法是根据换行符分割，True，False：指定是否保留换行符
test11='qwerer\nqweqw\nwafaef'
m5=test11.splitlines(True)
print(m5)

》》['qwerer\n', 'qweqw\n', 'wafaef']

startswith()、endswith()判断字符串是否以括号内参数开头或结尾

swapcace()大小写转换

replace()将字符串中指定字符或字符串用指定字符或字符串代替

test1="alexalexalexalexalex"
v1=test1.replace("ex","bbb",2)#2代表替换次数
print(v1)

》》albbbalbbbalexalexalex

 

6个基本方法：

jion()、spilt()、find()、strip()、upper()、lower()、replace()

黑科技：

1.索引,下标，获取字符串中的某一个字符

test='alex'
v0=test[0]
v1=test[1]
v2=test[2]
v3=test[3]
print(v0，v1，v2，v3)

》》a
》》l
》》e
》》x

#切片
v4=test[0:2]#表示从0到2，【0，2）前闭后开区间
print(v4)

》》al

############################
v5=len(test5)#获取当前字符串由几个字符组成
print(v5)

》》4

2.注：len()可用于其他数据类型，

li=[11,22,33,33]

print(len(li))#返回列表长度，用逗号分割

》》4

3.for i in      循环结构

test="python真的好简单"
i=0
while i<len(test):
    v=test[i]
    print(v)
    i+=1
print("#############")
》》p
y
t
h
o
n
真
的
好
简
单
#############

for i in test:
    print(i)


》》p
y
t
h
o
n
真
的
好
简
单

字符串一旦创建不可修改，一旦修改和拼接会在内存中重新创建新的字符串

 

 

3.布尔值 bool

4.列表 list

# list #类，列表
li = [1, 2, 9, "age", ["是正文", [19, 10]], 'wetrwe', True]  # 通过list类创建的对象，li
# 1.列表的格式：中括号括起来
# 用“，”分割每个元素
# 2.列表中可嵌套任何类型：列表中的元素可以是数字，字符串，列表，布尔值...所有的都能放进去
# "集合"，内部放任何东西

# 3.索引取值
print(li[3])
# 4.切片取值，结果也是列表
print(li[0:-1])

# 5.for循环
for item in li:
    print(item)

列表在内存中是按链表的方式存储的，列表中元素存储不连续，但每个元素所占内存都存储了下一个元素的坐标。所以列表元素与字符串元素不同，可以被修改

#链表，
li = [1, 2, 9, "age", ["是正文", [19, 10]], 'wetrwe', True]
# 6.列表元素修改
# 索引方式修改
li[1]=15649
print(li)

>>>[1, 15649, 9, 'age', ['是正文', [19, 10]], 'wetrwe', True]

# 切片方式修改
li[1:3]=[120,90]
print(li)

################

#删除列表元素
del li[1]
print(li)

# 7.切片方式删除
del li[2:5]
print(li)

################
# 8.in 操作

li = [1, 2, 9, "age", ["是正文", [19, 10]], 'wetrwe', True] 
v=120 in li
print(v)

v1="是正文" in li[4]
print(v1)
>>>False
>>>True

9.利用索引取值

li = [1, 2, 9, "age", ["是正文", [19, 10]], 'wetrwe', True]
#取出"19"
v=li[4][1][0]
print(v)

10.字符串转换为列表

#将字符串转换成列表，本质上去字符串中每一个元素进行for循环添加到列表中
s="wqrksldkfl"
new_s=list(s)
print(new_s)


>>>['w', 'q', 'r', 'k', 's', 'l', 'd', 'k', 'f', 'l']

#数字无法参与循环迭代，所以数字无法转换成列

11.将列表元素转换成字符串

#将列表元素转换成字符串
li=[11,22,33,"ww","rerd"]

v1=str(li)#将整个列表转换成字符串，相当于'[11,22,33,"ww","rerd"]'
print(v1)

>>>[11, 22, 33, 'ww', 'rerd']

v2=""
for i in li:
    v2+=str(i)
print(v2)

>>>112233wwrerd

#若列表中元素只有字符串，则可以用jion()方法
li_01=["fffwe","wqrewqr"]
v3="".join(li_01)
print(v3)

>>>fffwewqrewqr

基本方法：

1.append（）

#1.追加append()，在原来值后面追加
li=[11,22,1315,4]
v=li.append(5)#相当于什么都不是
print(v)
print(li)

>>>None
>>>[11, 22, 1315, 4, 5]

li.append("saf")
li.append(['wqeqw',12346])
print(li)

>>>[11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346]]

2.clear()清空列表

3.复制，拷贝copy()

4.count(value)计算元素出现的次数

 #2.清空列表clear（）li.clear()print(li)

>>>[]

#3.拷贝，浅拷贝，copy()
s=li.copy()
print(s)

>>>[11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346]]

#4.计算元素在列表中的个数count(Value)
c=li.count(11)
print(c)

>>>1

5.extend(iterable)扩展原来的列表，扩展元素必须是可迭代对象（字符串，列表等）

#5.extend(iterable)扩展原来的列表，扩展元素必须是可迭代对象（字符串，列表等）
li.extend(["wqewqe",657])
print(li)

>>>[11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346], 'wqewqe', 657]

与append()的区别：
li.append(["wqewqe",657])
print(li)

>>>[11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346], ['wqewqe', 657]]

###################

li.extend("不得了")
print(li)

>>>[11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346], '不', '得', '了']

li.append("不得了")
print(li)

>>>[11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346], '不得了']

6.index(Value,Start=None,End=None)

#6.index(Value,Start=None,End=None),根据值找索引
ind=li.index(22)
print(ind)

>>>1

7.insert(index，p_object)在指定索引位置插入指定元素

#7.insert(index，p_object)在指定索引位置插入指定元素
li.insert(0,'rrr4')
print(li)

>>>['rrr4', 11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346]]

8.pop(index)删除列表某个值（1.指定索引，2.默认是最后一个）并获取这个值

remove(Value)删除列表中的指定值，从左往右

ps：pop()  、 remove() 、 del list[0]  、del list[0:4]   、clear()

9.reverse()将当前列表反转

10.sort(key=None，reverse=False)，列表的排序，cmp，key  欠

li=[11,66,55,55,2,44]
li.sort()
print(li)

>>>[2, 11, 44, 55, 55, 66]


li.sort(reverse=True)
print(li)

>>>[66, 55, 55, 44, 11, 2]

对象.方法，# li对象调用append方法 

补充：列表创建后可以通过索引取值和修改值，字符串创建后可以通过索引取值但不可修改值

li=[11,22,33,44]

li[0]=999

print(li)

>>>[999,22,33,44]

s="alexs"

print(s[0])

>>>a

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

5.元组 tuple

#相当于对列表的二次加工，元组元素不可被修改，不能增加或删除

#tuple   类

tu=(111,222,"alex",(11,22,33),[0,1,2,3],True,5s5）

书写格式#一般写元组的时候，推荐在最后加入“，”，便于与方法区分

s="asf32 5we"
li=["y5rty","52"]
tu=("sgsdrrrt",['fff',456],526,)

v0=list(s)
print(v0)

v1=tuple(s)
print(v1)

v2=tuple(li)
print(v2)

v3=list(tu)
print(v3)

v4=str(li)
print(v4)

v5=str(tu)
print(v5)

#列表转换为字符串，当列表中只含有字符串时
l=["wrerewr","ewrewr","esadsad"]
v6="".join(l)
print(v6)

#元组转换为字符串，当元组中只含有字符串时
t=("ewrsgf","tryrty","241",)
v7="_".join(t)
print(v7)

>>>['a', 's', 'f', '3', '2', ' ', '5', 'w', 'e']

　>>>('a', 's', 'f', '3', '2', ' ', '5', 'w', 'e')
  >>>('y5rty', '52')
  >>>['sgsdrrrt', ['fff', 456], 526]
  >>>['y5rty', '52']
  >>>('sgsdrrrt', ['fff', 456], 526)
  >>>wrerewrewrewresadsad
  >>>ewrsgf_tryrty_241

 

#元组转换为字符串，当元组中不仅仅含有字符串时
s1=""
for i in tu:
    s1=s1+str(i)
print(s1)

>>>sgsdrrrt['fff', 456]526

元组也是有序的，元组的一级元素不可修改/删除/增加，但里面嵌套的列表可修改

#元组是有序的
tu=(123,5456,"asldw",[(545,555,)],True,3,4)
#找出555元素
print(tu[3][0][1])

>>>555

#####################
#元组的一级元素不可修改/删除/增加，但里面嵌套的列表可修改
tu[3].append(567)
print(tu)


>>>(123, 5456, 'asldw', [(545, 555), 567], True, 3, 4)

 

基本方法：

1.count（）获取指定元素在元组中出现的次数

2.index（）获取某个值的索引位置

6.字典 dict

#dict    类

1.字典的value可以是任何值

info={

　　"k1":"v1",#键值对 

　　"k2":"v2"}

#字典的value可以是任何值
info1={
    "k1":23,
    "k2":True,
    "k3":[11,22,22,{
        'kk1':'vv1',
        'kk2':'vv2',
        'kk3':(44,55,)
    }],
    "k4":(34,54,6,)
}
print(info)

>>>{'k1': 23, 'k2': True, 'k3': [11, 22, 22, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (44, 55)}], 'k4': (34, 54, 6)}

 2.列表和字典不能作为字典的key

#列表和字典不能作为字典的key
info2={
    123:'erwer',
    "k1":'rewr',
    (33,44,):'ertd',
    True:'fgf',
}
print(info2)

>>>{123: 'erwer', 'k1': 'rewr', (33, 44): 'ertd', True: 'fgf'}

3.字典是无序的

4.可以根据索引输入字典键值key获取对应的值，不可通过切片查找，因为无序

#获取‘ertd’
v2=info2[(33,44,)]
print(v2)

#获取'44'
v1=info1['k3'][3]['kk3'][0]
print(v1)

5.字典元素的删除

del info['k3'][3]['kk1'']

6.字典的for循环

#for循环
for item in info1:#默认获取key值
    print(item)

for item in info1.keys():
    print(item)

for item in info1.values():#获取value
    print(item)

for k,v in info1.items():#获取Key和value
    print(k,v)

基本方法

1.clear()删除

2.copy()复制,浅复制

@staticmethod 静态方法，支持直接写类名后带“.”可执行该功能如dict.fromkeys

3.dict.fromkeys（）根据序列，创建字典，并指定统一的值

v=dict.fromkeys(["k1",123,"9990"],12345)
print(v)

>>>{'k1': 12345, 123: 12345, '9990': 12345}

4.get()

info={
    "k1":"v1"
}

a=info.get("k1",456478)#45678为默认若取不到相应的键值则返回的值
print(a)

b=info.get("rewrwer","wqerqwr")#若不传入值，则默认返回None
print(b)

>>>v1
>>>wqerqwr

5.pop(k,d=None)，删除传入k值，返回当前删除的key值，当k不存在字典中时，返回d，默认为None

6.popitem()，删除字典中的值，返回键值对，默认返回元组类型，若k,v=popitem()，则返回两个值

a1=info.pop("k122",999)
print(a1)
print(info)

a2=info.popitem()
print(a2)
print(info)

a3,b3=info.popitem()
print(a3,b3)
print(info)

>>>999
>>>{'k1': 'v1', 'k2': 'v2'}
>>>('k2', 'v2')
>>>{'k1': 'v1'}
>>>k1 v1
>>>{}

7.setdefalt(k,d=None)在字典中设置值，若已存在，则获取当前key对应的值，若不存在则设置值并获取当前对应的值，

info={
    "k1":"v1",
    "k2":"v2"
}

a1=info.setdefault("k1",123)
print(info,a1)
a2=info.setdefault("rree",123)
print(info,a2)

>>>{'k1': 'v1', 'k2': 'v2'} v1

>>>{'k1': 'v1', 'k2': 'v2', 'rree': 123} 123

8.update(E=None,**F)***kwargs这种参数python将自动转换成相应的格式

info={
    "k1":"v1",
    "k2":"v2"
}

info.update({'k1':454,"k3":48478})
print(info)

info.update(k1=123,k3=48789,k4="erwr")
print(info)

>>>{'k1': 454, 'k2': 'v2', 'k3': 48478}
>>>{'k1': 123, 'k2': 'v2', 'k3': 48789, 'k4': 'erwr'}

 

总结

一、数字

int（）

二、字符串

replace/fin/jion/strip/startwith/spilt/upper/lower/format

例：

template="I am {name},age:{19}"

v=template.formate(**{"name":"alex","age":19})

print(v)

三、列表

append/extend/insert

索引、切片、循环

四、元组

索引、切片、循环

一级元素不能被修改增加删除

五、字典

get/update/keys/values/items

for，索引

例：in在字典的用法

　　dic={ "k1":"v1"}

　　v="k1"in dic

　　print(v)

六、布尔值

0 1 

bool（）

0，None，“”，（），[ ]，{ }都是False，其余都是True

 

 

补充：

enumrate(object，)，为可迭代对象添加序号

li = [11,22,33]
for k,v in enumerate(li, 1):
    print(k,v)

>>>1 11
>>>2 22 
>>>3 33