python基础—基本数据类型—数字，字符串，列表，元组，字典

1、运算符

（1）基本运算符

　　　+  加法

　　  -   减法

*   乘法

/   除法

**   幂

//   取整（除法）

%   取余（除法）

（2）判断某个东西是否在某个东西里面包含

　　in

　　not  in

（3）结果是值

　　a、算术运算

　　　　a=10*10

　   b、赋值运算

　　　　a=a+!    a+=1　

（4）结果是布尔值

　　a、比较运算

　　　　a=1>5

　　b、逻辑运算

　　　　a=1>6 or 1==1    一方为真则为真

　　　　a=1>6 and 1==1   同时为真则为真

　　c、成员运算

　　　　a="小"  in "小缠绵"

　　　　a="小" not in "小缠绵"

2、基本数据类型

（1）、数字    int

　a、int 将字符串转换为数字 　　　　　

a="123"
print(type(a),a)    #<class 'str'> 123

b=int(a)
print(type(b),b)    #<class 'int'> 123

num="0011"
v=int(num,base=2)
print(v)            #以二进制的形式 v=3

　b、 bit_length 当前数字的二进制，至少用n位表示 　

age=2

r=age.bit_lenght()

print(r)　　#2， 2的二进制为11，如果age=5,则输出为3，因为5的二进制为101

（2）、字符串   str　　

python中字符串有三种表现形式，分别是单引号，双引号，三引号

字符串一旦创建，不可修改
一旦修改或者拼接，都会造成重新生成字符串

　a、首字母大写   capitalize()

test="alex"
v=test.capitalize()
print(v)

b、所有的字符变小写  casefold()和lower()

区别：casefold()可以改变很多未知的,lower()只能改变熟知的

test = 'alex'
v1=test.casefold()
print(v1)
v2=test.lower()
print(v2)

c、设置宽度，并将内容居中 center()

test = 'alex'
v3=test.center(20,"*")   # 20 代指总长度，*空白位置填充,一个字符，可有可无

d、字符串中寻找子序列出现的次数 count(sub,start=None,end=None)

　　sub:子序列

　　start:起始位置，默认为空

　　end:终止位置，默认为空

test = 'alex'
v4=test.count('l'，1,4)

　e、判断以什么结尾/开头，endswitch(suffix, start=None, end=None)和startswitch(suffix, start=None, end=None)

　　suffix:需要判断你的字段

　　start:起始位置

　　end:终止位置

　　返回值为布尔值

test = 'alex'
v5=test.endswith('ex',1,4)
v6=test.startswith('a')

f、从开始往后找，找到第一个后，获取其位置

　①find()

test = 'alex'test.find('ex')  >>2

　②index()

test = "alex"
test.find('ex')   >>2   # 说明如果找不到会抛出一个异常

　g、格式化，将一个字符串种的占位符替换为指定的值

(1)指定参数

test='I am {name},age {a}'
print(test)
v=test.format(name='Christian',a=26)
print(v)

(2)根据索引

test1='I am {0},age {1}'
print(test1)
v1=test1.format('C',19)
print(v1)

h、字符串中是否只包含 字母和数字 结果为Ture False

v=test.isalpha()　

i、当前输入是否是数字

　①、只判断数字，对于特殊字符以及汉字不支持

test="二"
v1=test.isdecimal() 　 >> False

　②、可以含有特殊字符，比如②,不支持汉字　　

v2=test.isdigit()  >> False

test1 = "②"

test1.isdigit()   >> True

　③、同时支持数字，汉字，以及特殊字符

test = '二'
test.isnumeric()   >>True
test1 = '②'
test1.isnumeric()  >>True
test2 = "2"
test2.isnumeric()  >>True

j、判断是否存在不可显示的转义字符，若没有，输出ture,否则false

test="ssfsgghh\t"
test.isprintable()   >>False  # 返回False 表示存在

test = "safaf\\t"
test.isprintable()  >>True   # 返回True 表示不存在

k、判断是否全是空格,是输出Ture,否则False

test=' '
v=test.isspace()   >>True

l、判断是否是标题(标题每个单词的首字母都是大写)并转换为标题

test='dafgg gsgh hfsfs'

v1=test.istitle()      # 判断是否为标题
print(v1)       #输出V1为False
v2=test.title()     # 转化为标题
print(v2)　　　　　　#输出v2为Dafgg Gsgh Hfsfs
v3=v2.istitle()
print(v3)　　　　#输出v3为 Ture

　m、将字符串中的每一个元素按照指定分隔符进行拼接

test="你是风儿我是沙"
print(test)    #你是风儿我是沙
t=' '
v1=t.join(test)
v2='_'.join(test)
print(v1)    #你 是 风 儿 我 是 沙
print(v2)　　#你_是_风_儿_我_是_沙　

　n、设置内容宽度，并将内容居左，居中，居右显示

　①、将内容居中　　

test="alxe"
v=test.center(20,"中")  #20代指总长度，空白未知填充一个字符，可有可无
print(v)    #中中中中中中中中alxe中中中中中中中中　

　②、将内容居左　

test="alex"
v1=test.ljust(20,"中")
print(v1)          #alex中中中中中中中中中中中中中中中中

③、内容居右显示　　

test="alex"
v2=test.rjust(20,"中")
print(v2)       #中中中中中中中中中中中中中中中中alex　

　O、大小写转换(对整个字符串，要么全是大写，要么全是小写)

　①、判断是否全部为小写并转换为小写islower()和lower()

test="Christian"
v1=test.islower()
print(v1)                    #False
v2=test.lower()
print(v2)                #christian
v3=v2.islower()
print(v3)                #ture

　②、判断是否全部为大写并转换为大写isupper()和upper()

test="Christian"
v1=test.isupper()
print(v1)                    #False
v2=test.upper()
print(v2)                #CHRISTIAN
v3=v2.islower()
print(v3)                #ture　　

　p、大小写转换(对字符串中的大写字符转换为小写，小写字符转换为大写)

test="Christian"
v=test.swapcase()
print(v)   #cHRISTIAN

q、移除指定字符串

　①、strip()

test = "   Christian     "
test.strip()   >>Christian

　②、lstrip()

test = "    Christian    "
test.lstrip()  >>"Christian    "

　③、rstrip()

test = "    Christian    "
test.rstrip()  >>"    Christian"

r、按照指定字符分割字符串，返回列表

test = "Christian   Negan   Alex"
test.split()   >>["Christian", "Negan", "Alex"]

s、索引方式获取字符串中的某一个字符

test='ALEX'
test[0:3]     >>ALE    #区间0<=X<3,包头不包尾
test[0]    >>A     #第一个字符
test[-1]   >>X     # 取最后一个字符　

　t、获取字符串的长度

test = 'Negan'
len(test)   >>5

　u、字符替换 replace(self, old, new, count=None)

test= “Christian”
test.replace('i', '')   >>Chrstan

　v、一个一个输出字符串的内容

　①、while循环

idex=0
test="我要好好学习Python"
while idex < len(test):
    v=test[idex]
    print(v)
    idex+=1

print('end')

　②、for循环

　　 for 变量名 in 字符串：

test="我要好好学习Python"
for idex in test:
    print(idex)

　w、获取字符串中最大和最小字符

①、最大字符 max()　

test = "Christian"
max(test)  >>"t"

　②、最小字符 min()

test = "Christian"
min(test)   >>"t"

（3）、列表   list　

　　中括号括起来,用"，"分割每个元素,元素可以是数字，字符串，列表，bool值……总之所有的东西都能放进去　

　　索引取值,结果是元素

　　切片，切片结果是列表

　　列表元素可以被修改(内存地址不会被改变)

　a、修改

　　①、索引的方式进行修改

li=[234,222,'assx',['sssa','sss',[1]]]
li[1]='age'  
li > [234, 'age', 'assx', ['sssa', 'sss', [1]]]

　　②、切片的方式进行修改

li=[234,222,'assx',['sssa','sss',[1]]]

li[1:3]=[2,'a']  >> [234, 2, 'a', ['sssa', 'sss', [1]]]

　b、删除

　 ①、索引方式

li=[234,222,'assx',['sssa','sss',[1]]]
del li[1]
li   >> [234,'assx',['sssa','sss',[1]]]

　②、切片方式同样适用　

li=[234,222,'assx',['sssa','sss',[1]]]
del li[0:2]
li  >> ['assx',['sssa','sss',[1]]]　

　c、在原来的值后面追加

　①、append(object)

　list.append(object) 向列表中添加一个对象object　　

　使用append的时候，是将new_media看作一个对象，整体打包添加到music_media对象中。

music_media = ['compact disc', '8-track tape', 'long playing record']
new_media = ['DVD Audio disc', 'Super Audio CD']
music_media.append(new_media)
music_media  >>['compact disc', '8-track tape', 'long playing record', ['DVD Audio disc', 'Super Audio CD']]

　②、extend(sequence)

　扩展原来的列表，参数为可迭代对象，内部执行for循环　　

　list.extend(sequence) 把一个序列seq的内容添加到列表中

　使用extend的时候，是将new_media看作一个序列，将这个序列和music_media序列合并，并放在其后面。

music_media = ['compact disc', '8-track tape', 'long playing record']
new_media = ['DVD Audio disc', 'Super Audio CD']
music_media.extend(new_media)
music_media   >>> ['compact disc', '8-track tape', 'long playing record', 'DVD Audio disc', 'Super Audio CD']　　

　d、清空列表 clear()　　

li = [1,2,3]
li.clear()
li   >> []　

　e、拷贝(浅拷贝)　　　

li = [1,2,3]
v=li.copy()
v  >> [1,2,3]

　f、计算元素在列表中出现的次数　

li=[1,2,3,4,1]
v=li.count(1)
v >> 2

g、根据值获取当前值索引位置（左边优先）　　

li=[234,222,'assx',['sssa','sss',[1]]]

v=li.index(222)

v >>1

h、在指定索引位置插入元素

　　insert(self, index, p_object)　

li=[234,222,'assx',['sssa','sss',[1]]]
li.insert(0,"chen")
li  >>['chen', 234, 222, 'assx', ['sssa', 'sss', [1]]]

i、pop删除某个值（指定索引，默认是最后一个），并返回当前的值

　　pop(self,index=None)　改变原列表，内存地址不会发生改变

li=[234,222,'assx',['sssa','sss',[1]]]
v=li.pop(0)
li  >>[222, 'assx', ['sssa', 'sss', [1]]]
v   >>234

j、删除列表中的指定值，左边优先

　　 remove(self,value)　　改变原列表，内存地址不会发生改变

li=[234,222,'assx',['sssa','sss',[1]]]
li.remove(234)
li   >>[222, 'assx', ['sssa', 'sss', [1]]]　

　 k、将当前列表进行反转

　　reverse(self)　　

li=[234,222,'assx',['sssa','sss',[1]]]
li.reverse()
li  >>[['sssa', 'sss', [1]], 'assx', 222, 234]

　 l、排序　

　sort(self,key=None, reverse=False)    默认从小到大

li=[234,222,22345]
li.sort(reverse=1)   # 1表示为True,倒序排列
li  >>[22345, 234, 222]

　扩展：

　sort()是应用在list上的方法，对已经存在的列表进行操作 ，无返回值。

　sorted()函数对所有可迭代对象进行操作（所有能被for循环的都是可迭代对象），会返回一个新的list

li=[234,222,22345]
sorted(li, reverse=True)   >> [22345,234,222]　　

　m、列表转换成字符串

　①、既有数字又有字符串需要自己写for循环一个一个处理　

li=[11,22,33,'123','Alex']
s=''
for item in li:
    s=s+str(item)
 s  >>112233123Alex

　②、如果只有字符串,用join()方法

　　和字符串中的join方法类似

li=["123",'alex']
v=''.join(li)
v  >>123alex

　n、列表生成式

l = [i  for i in range(10) if i % 2 == 0]

l >> [0,2,4,6,8]

（4）、元祖  tuple

　　元素不可被修改，不能被增加或者删除（一级元素不可被修改）

　　tu=(111,222,333)

　　count 获取指定元素在元组中出现的位置

　　index 获取指定元素在元组中出现的次数　

　　注意：如果元祖中只有一个元素，元素后面需要加一个“，”。

tu=(111,"alex","Christian",111,34)
v1=tu.count(111)
v2=tu.index(111)
print(v1,v2)

>>>>2 ,0

（5）、字典  dict

　　字典的value可以使任意值

　　列表，字典不能作为字典的key

　　字典是无序的

　　字典支持del

　　字典可以for循环

　a、输出字典的Key值　　

info={"K1":"V1",
     "K2":"V2"}
for item in info.keys():
    print(item)   

>>K1
  K2

　b、输出字典的value　

info={"K1":"V1",
　　　　"K2":"V2"}
for item in info.values():
    print(item) 

>>1
　2

　c、同时输出字典的键和值

①手动输出

info={"K1":"V1",
　　　　"K2":"V2"}
for item in info.keys():
    print(item,info[item])

>> K1 V1
　 K2 V2

②自动循环输出键值对

info = {"K1": "V1","K2": "V2"}
for k,v in info.items():
       print(k,v)
>> K1 V1
   K2 V2

d、根据序列，创建字典，并指定统一的值

v=dict.fromkeys(['k1','k2','k3'],123)
v  >>{'k1': 123, 'k2': 123, 'k3': 123}

　e、根据key获取值

　①使用get()获取，如果key不存在，则返回None

info = {"K1": "V1","K2": "V2"}
v=info.get('K1')
v >> v1

　②、通过索引key获取，如果key不存在，会报错

info = {"K1": "V1","K2": "V2"}
info['K1']  >> V1

info['K3']   >> KeyError  # 对于不存在的key,会抛出异常。

　f、设置值

　①、通过key设置value

　如果存在key,则更改对应的value值，如果不存在，则给字典新增key和value

dic = {'a':1, 'b':2}
dic['a'] = 22 # 更改
dic  >> {'a':22, 'b':2}
dic['c'] = 33   # 增加
dic >> {'a':22,'b':2,'c':33}

　②、setdefault

　　key已存在，不设置，获取当前key对应的值
　　key不存在，设置，获取当前key对应的值

info = {"K1": "V1","K2": "V2"}
V=info.setdefault('K1', 22)
info.setdefault('k3',11)
V >> V1
info >> {'K1': 'V1', 'K2': 'V2', 'k3': 11}

　g、更新　

info = {"K1": "V1","K2": "V2"}
info.update({'K1':11})
#info.update(K1=11)

info  >>{'K1': 11, 'K2': 'V2'}