python逻辑型数据也叫什么_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) # 123

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

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

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

age=2r=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

v=test[idex]print(v)

idex+=1

print('end')

②、for循环

for 变量名 in 字符串：

test="我要好好学习Python"

for idex intest: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 inli:

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 ininfo.keys():print(item)>>K1

K2

b、输出字典的value

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

>>1

2

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

①手动输出

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

K2 V2

②自动循环输出键值对

info = {"K1": "V1","K2": "V2"}for k,v ininfo.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 >> V1info >>{'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'}