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

最新推荐文章于 2022-03-25 00:23:33 发布

weixin_33725272

最新推荐文章于 2022-03-25 00:23:33 发布

阅读量118

点赞数

原文链接：http://www.cnblogs.com/huiyichanmian/p/8508254.html

版权

1.安装python的ied pycharm(专业版勿汉化)

2.运算符

　　+，-，*，/ , **, //, %

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

　　not in

　　结果是值

　　　　算术运算

　　　　　　　a=10*10

　　　　赋值运算

　　　　　　　a=a+! a+=1

　　结果是布尔值

　　　　比较运算

　　　　　　a=1>5

　　　　逻辑运算

　　　　　　a=1>6 or 1==1

　　　　　　a=1>6 and 1==1

　　　　成员运算

　　　　　　a="小" in "小缠绵"

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

3.基本数据类型

　　数字 int

　　-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

　　- bit_length
　　　　当前数字的二进制，至少用n位表示
　　　　r=age.bit.length()

　　　　age=2

　　　　r=age.bit_lenght()

　　　　print(r)　　#2

　　字符串 str　　

　　#首字母大写

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

#所有的变小写 casefold很多的未知的都可以改变
lower只能变化熟知的

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

#设置宽度，并将内容居中
20 代指总长度，*空白位置填充,一个字符，可有可无

v3=test.center(20,"*")

#字符串中寻找子序列出现的次数，两个参数是起始位置和终止位置，可有可无

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

#判断以什么结尾/开头，两个参数是起始和终止，可有可无,输出结果为True or False

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

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

v7=test.find('ex')

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

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

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

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

v=test.isalpha()

#当前输入是否是数字

　　#只判断数字

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

　　#可以含有特殊字符，比如②　　

　　v2=test.isdigit()

　　#可以含有汉字　　

　　v3=test.isnumeric()

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

　　test="ssfsgghh\t"
　　v=test.isprintable()
　　print(v)

　　#输出False

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

　　test=' '
　　v=test.isspace()
　　print(v)

　　#输出  Ture

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

　　　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

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

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

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

 　　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

　#大小写转换

　#判断是否全部为大写/小写

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

#移除指定字符串
#移除空白，/t，/n
#lstrip()
#rstrip()

　　test="Christian"
　　v=test.strip('an')
　　print(v)    #  Christi

#大小写转换

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

=============================================================================================================

黑魔法

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

#获取字符串由多少个字符组成

　　test='ALEX'
　　v=test[0:3]     #区间0<=X<3
　　v1=test[0]      #第一个字符
　　print(v)     #ALE
　　print(v1)    #A

#获取字符串由多少个字符组成

test="Christian"
v=len(test)
print(v)     #9

#一个一个输出字符串的内容　

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)

　#替换

replace(self, old, new, count=None)

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

列表 list

　　中括号括起来
　　，分割每个元素
　　列表中的元素可以使数字，字符串，列表，bool值……所有的都能放进去
　　“集合”，内部可以放置任何东西

　　索引取值,结果是元素

　　切片，切片结果是列表

　　列表元素可以被修改

　　#修改

　　索引的方式进行修改

li=[234,222,'assx',['sssa','sss',[1]]]
li[1]='age' 
print(li)
li=[234, 'age', 'assx', ['sssa', 'sss', [1]]]

　　切片的方式进行修改

li[1:3]=[2,'a']  
#输出结果：

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

　　删除

　　索引方式

li=[234,222,'assx',['sssa','sss',[1]]]
del li[1]
print(li)   #删除列表中的222

　　切片方式同样适用

li=[234,222,'assx',['sssa','sss',[1]]]
del li[0,2]
print(li)    #切片方式删除列表中的234，和222

　　在原来的值后面追加

　　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)
print music_media
>>>['compact disc', '8-track tape', 'long playing record', ['DVD Audio disc', 'Super Audio CD']]

　　扩展原来的列表，参数为可迭代对象，内部执行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)
print music_media
>>>['compact disc', '8-track tape', 'long playing record', 'DVD Audio disc', 'Super Audio CD']

　　清空列表
　　li.clear()

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

　　拷贝,浅拷贝
　　v=li.copy()
　　

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

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

　　.count(参数)

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

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

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

　　v=li.index(222)
　　print(v)

　　>>>>1

　　在指定定索引位置插入元素
　　def insert(self, index, p_object)

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

　　pop删除某个值（指定索引，默认是最后一个），并获取当前的值

　　def pop(self, index=None)

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

>>>>>[222, 'assx', ['sssa', 'sss', [1]]]
>>>>>234

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

　　def remove(self, value)

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

>>>>>[222, 'assx', ['sssa', 'sss', [1]]]

　　将当前列表进行反转

　　def reverse(self)

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

>>>>>[['sssa', 'sss', [1]], 'assx', 222, 234]

　排序　

def sort(self, key=None, reverse=False)

　默认从小到大　

li=[234,222,22345]
li.sort(reverse=1)
print(li)
>>>>>>[22345, 234, 222]

　　列表转换成字符串
　　需要自己写for循环一个一个处理（既有数字又有字符串）

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

　　如果只有字符串,用join

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

>>>>>>123alex

　　元祖 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

　　字典 dict

　　字典的value可以使任意值

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

　　字典是无序的

　　字典支持del

　　字典for循环

　　#输出字典的Key值　　

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

　　#输出字典的value

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

>>>>>>V1
　　　　V2

　　手动同时输出字典

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

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

v=dict.fromkeys(['k1','k2','k3'],123)
print(v)

>>>>>{'k1': 123, 'k2': 123, 'k3': 123}

　　根据key获取值，key不存在时，可以指定默认值（none）

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

>>>>>V1

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

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


>>>>>V1
{'K1': 'V1', 'K2': 'V2', 'k3': 11}

　　更新

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

print(info)

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

　　布尔值 bool

转载于:https://www.cnblogs.com/huiyichanmian/p/8508254.html

weixin_33725272

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python基础—基本数据类型—数字，字符串，列表，元组，字典

1.安装python的ied pycharm(专业版勿汉化)2.运算符　　+，-，*，/ , **, //, %　　判断某个东西是否在某个东西里面包含　　in　　not in　　结果是值　　　　算术运算　　　　　　　a=10*10　　　　赋值运算　　　　　　　a=a+! a+=1　　　　　结果是布尔值　　　　比较运算　　　...
复制链接

扫一扫