基本数据类型 Basic data types

基本数据类型

1.数字 int

python3所有整形都是，int
python2整形有，int、long两种（int有长度限制）
功能：
—int 将字符串转换成数字

#将字符串转换成数字
b='123'
print(type(b),b)
a=int(b)
print(type(a),a)
#以16进制的方式转换b为10进制
num1='b'
v=int(num1,base=16)
print(v)
#以2进制的方式转换b为10进制
num ='011'
v1=int(num, base=2)
print(v1)

—bit_length()

#当前数字的二进制至少用N位表示
r=99
V2=r.bit_length()
print(V2)

2.字符串 str

***必会：join ，split，find，strip，upper，lower，replace；
len（），for循环，索引，切片，range
***字符串一旦创建，不可修改
***一旦修改或者拼接，都会造成重新生成字符串

join ，split，find，strip，upper，lower
#索引，下标，获取字符串中的某一个字符
test=‘alex’
v=test[0]
print (v)
#切片
test=‘alex’
v=test[0:2]#>=0,<2
print(v)
#for循环
#for 变量名 in 字符串：
     # print（变量名）
for des in test:
    print(des)
#获取字符串中有几个字符组成
v= len(test)
print(v)

#首字母大写
string='alex'
s=string.capitalize()
print(s)
#所有字母小写,很多的未知的字母变小写
s1=s.casefold()
print(s1)
#所有字母小写，对英文字母
s2=s.lower()
print(s2)
#设置宽度将‘Alex’居中
#20代表总长度
#* ，空白 代表未知填充
#填充只能写一个字符不能写‘99’或者‘**’
wide=s.center(20)
print(wide)
wide=s.center(20,'*')
print(wide)
##设置宽度将‘Alex’居左
#20代表总长度
#* ，空白 代表未知填充
#填充只能写一个字符不能写‘99’或者‘**’
test='Alex'
v=test.ljust(20,'*')
print(v)
#设置宽度将‘Alex’居右
test='Alex'
v=test.rjust(20,'*')
print(v)
#去字符串中寻找，寻找子序列出现的次数
string='alexalexalex'
s3=string
count1=s3.count('ex')
print(count1)
#从字符下标0开始到9结束‘ale’出现的次数，下面范围（>=0,<10）
count1=s3.count('ale',0,10)
print(count1)
#以什么结尾,
# 从字符下标0开始到9结束，以al开始，下面范围（>=0,<10）
v2=s3.endswith('ex')
print(v2)
v3=s3.startswith('al',0,10)
print(v3)
#从开始往后找找到第一个‘ex’获取其下标
v2=s3.find('ex')
print(v2)
#从下标5开始往后找找到下标6结束，的第一个‘ex’获取其下标，下面范围（>=5,<7）
#找不到打印-1
v2=s3.find('ex',5,7)
print(v2)
#格式化，将一个字符串中的站位符替换成指定的值
test ='i am {name} age {a}'
print(test)
f =test.format(name='lijunyang',a=18)
print(f)
#第二种写法，用0,1,2,3,数字站位，替换时候不用指定位置，直接按照顺序取值
test ='i am {0} age {1}'
print(test)
f =test.format('lijunyang',18)
print(f)
#格式化，format_map，传入的值{'name':'lijunyang','a':19}
test ='i am {name} age {a}'
print(test)
f =test.format_map({'name':'lijunyang','a':19})#字典
print(f)
#index ,查找下标跟find一样，find找不到报-1，index找不到直接报错
#test ='alexalex'
#test.index('8')

#判断字符串里是否为全为数字哥字母
test='123abc'
t=test.isalnum()
print(t)
#expandtabs，断句,以长度=20为一组断句，没有\t就一直到20哥为一组，遇到\t就中断把不足二十的补到20
test ='username\temail\tpassword\nlijunyang\tlijunyang@163.com\t123\nlijunyang\tlijunyang@163.com\t123\nlijunyang\tlijunyang@163.com\t123\n'
v=test.expandtabs(20)
print(v,len(v))
#判断字符串是否是字母，汉字
test ='aq1234'
v1=test.isalpha()
print(v1)
#判断字符串是否是数字字符串，isdecimal判断是否为十进制数字，digit判断是否为数字包含特殊数字如②，snumeric判断是否为数字支持中文如二、贰中文不支持
test ='一'
v1=test.isdecimal()
v2=test.isdigit()
v3=test.isnumeric()
print(v1,v2,v3)
#判断字符串是有效的python标识符，是返回true(字母，数字，下划线：标识符def class)，否则返回false,
test= '_123'
v=test.isidentifier()
print(v)
#isprintable,打印是是否存在不可显示的字符，如\t(制表符)，\n(换行符)，存在为false
test='ajsdhajhdjk\tkhjsdka'
v=test.isprintable()
print(v)
#判断字符串是否全部是空格
test='   '
v=test.isspace()
print(v)
判读字符串是否为标题（所有单词首字母大写）
test='A string is a digit string if all characters in the string are digits and there'
#字符串转换为标题所有单词首字母大写
v1=test.title()
print(v1)
v2=test.istitle()
v3=v1.istitle()
print(v2,v3)
#将字符串中的每一个元素按照指定分隔符进行拼接
test='我是大帅锅'
print(test)
t='|'
v=t.join(test)
v1="*".join(v)
print(v,v1)
#字符串全部转变小写
test='Alex'
#判读是否全为小写
v1=test.islower()
#转换为小写
v2=test.lower()
print(v1,v2)
#字符串全部转变大写
test='Alex'
#判读是否全为大写
v1=test.isupper()
#转换为大写
v2=test.upper()
print(v1,v2)
#去除右边空格、左边空格、所有空格、或者\r,\t
test=' alex '
v1=test.rstrip()
v2=test.lstrip()
v3=test.strip()
#去除指定内容
# 优先最多匹配'9axl'，一次匹配'9axl'的子字符串去除
v4=test.strip('9axl')
#
v='qwyewuqehdjashdwqueqiwu'
#前后字符串对应映射相等
m=str.maketrans('wertq','12346')
#替换掉v字符串的原始值为映射后的值
new_v=v.translate(m)
#按照以'st'为节点分割字符串从左往右或者从右向左，分割后的字符串是有分隔符的。并且取到以第一个分隔符就停止匹配
#分割完只有三个字符串
test='testtesttesttesttest'
v1=test.partition('st')
v2=test.rpartition('st')
print(v1,v2)
#按照以's'为节点,分割字符串从左往右或者从右向左,分割后的字符串是无分隔符的，无线分割到分完为止
v3=test.split('s')
v4=test.rsplit('s')
print(v3,v4)
#按照以's'为节点,分割字符串从左往右或者从右向左,分割后的字符串是无分隔符的，可指定分割次数
v3=test.split('s',2)
v4=test.rsplit('s',2)
print(v3,v4)
#根据换行分割，splitlines()括弧加参数Ture分割后留下\n,加Fales分割后不留\n，不填默认false
test='qtwqywqyw\nqwqwqwqwn\nqwqwqwqw\n'
v=test.splitlines()
#判断以XXX开头，XXX结尾
test='backname  1.1.1.'
v=test.startswith('ba')
v2=test.endswith('1.')
print(v,v2)
#大小写转换，大写全部转为小写，小写全部转为大写
test='alaQWE'
v=test.swapcase()
print(v)
#替换,把前两个“ex”替换为“bbb”
test='alexalexalex'
v=test.replace('ex','bbb',2)
print(v)

#帮助创建连续的数字,通过设置步长来制定不连续
v=range(0,100)
#输入一个字符串，分行打印并打印下标

#输入一个字符串赋值给test
test=input('<<<<<')
#循环0，到输入字符串长度连续数字
for des in range(0,len(test)):
    #打印字符串下标，打印字符串对应下标的字母
    print(des ,test[des])


#输入字符串赋值给test
test=input('<<<<<')
#打印test
print(test)
#取到test字符串长度
l=len(test)
#创建从0到字符串长度，连续的数字
v=range(0,l)
#循环连续数字集v
for des in v:
   # 打印V，和下标为v的字母
    print(des,test[des])

3.列表 list

类：
1.中括弧括起来
2.以，分割每个元素
3.列表中的元素可以是：数字，字符串，列表，布尔值，字典，元祖等所有都可以放
4.“集合”，内部放置任何东西
5.索引取值
6.切片取值
7.支持for循环

8. in 操作
   9.字符串转换为列表，列表转换为字符串

#字符串转换为列表
a='wqwqwqsasqwqwqw'
lit=list(a)
print(lit)
# 列表转换为字符串，需要自己写for循环一个一个处理，既有数字又有字符串
tr = [1, 2, 3, 4, 'qwe', 23, '2222', True]
al = ''
for TR in tr:
    str(TR)
    al = al + str(TR)
    print(al)
#列表如果元素都是字符串可以用join拼接
ts=['qwwqwqw','12121','qwqwqw']
TS=''.join(ts)
print(TS)

# 列表list

li = [1, 2, 3, 14, 'age', ['age', 11, [1, 'lili']], True]
#循环
for des in li:
    print(des)
# 取值
# 下标
l = li[3]
print(l)
# 取li列表的'lili'(一层一层按照索引取值)
l = li[5][2][1]
print(l)
# 切片取值
l = li[0:5]
print(l)
# 修改
li[2] = 300
print(li)
li[0:2] = [100, 200]
print(li)
#删除，第一种方式
del li[1]
print(li)
#以切片方式删除
del li[1,5]
print(li)
#     in
lq = [1, 2, 3, 14, 'age', ['age', 11, [1, 'lili']], True]
v = 3 in lq
print(v)

list提供的方法

• 1.追加 append（）
• 2.清除 clear（）
• 3.拷贝 copy（）
• 4.统计 count（）
• 5.扩展原列表 extend()
• 6.根据值获取当前值所在索引位置 （左边优先） index（）
• 7.删除列表中的某个值（1.未指定索引默认最后一个2.指定索引）,并获取删除的值pop（）
• 8.删除列表中的指定值，左边优先remove（）
  PS：删除有remove、pop、del li [0]、del li[7:9] 、clear
• 9.反转 reverse()
• 10.排序sort（）
• 11.插值insert（）

# 原来值后面追加,追加的内容可为数字、字符串、列表
tq = [1, 2, 3, 4]
tq.append(5)
print(tq)
tq.append([123112, 121212])
print(tq)
tq.append('zhuijia')
print(tq)
#清除
tq.clear()
print(tq)
#拷贝，浅拷贝
v=tq.copy()
print(v)
#计数，统计列表某个元素的出现个数
s=tq.count(2)
print(s)
#扩展原列表；参数为可迭代对象（可for循环对象）
tq.extend(['dsddsd','fdgddfd'])
print(tq)
tq.extend('大水哥')
print(tq)
#根据值获取当前值所在索引位置 （左边优先）
p=[1,2,3,4,5,2,6]
v=p.index(2)
print(v)
#删除列表中的某个值（1.未指定索引默认最后一个2.指定索引）,并获取删除的值
#不知道索引
v=p.pop()
print(v)
print(p)
#指定索引
v=p.pop(2)
print(v)
print(p)
#删除列表中的指定值，有重复的值左边优先只删一个
p.remove(2)
print(p)
#将当前列表进行反转
p.reverse()
print(p)
#排序
q=[1,3,6,2,4,5]
q.sort()#升序
print(q)
q.sort(reverse=True)#降序
print(q)
#插值
a=[12,22,33,44,55]
a.insert(0,99)
print(a)

PS
字符串一旦创建不可修改，
列表是有序的，元素是可以被修改，

4.元祖tuple

• 对列表的二次加工，元素不可被修改，不能增加或者修改删除
• tu= (111,'asasa',(1,2),[(22,44)],True33,)
• 元祖里面可以放，字符串，数字，列表，元祖，布尔值
  PS一般写元祖时候在最后加一个逗号
  元祖可被取值
• 1，索引
• 2，切片
• 3，可以被for循环，可迭代对象
• 4，字符串，列表，元祖可相互转换
• 5.tu= (111,'asasa',(1,2),[(22,44)],True33,)
  元祖的第一级元素不能修改增加删除，当元祖内嵌套的的列表的元素（二级元素），可被修改删除

tuple提供的方法

• 1统计 count（）
• 2根据值获取当前值所在索引位置 （左边优先）index（）

5.字典dict

• {key:value,key:value}
• 布尔值、列表、字典不能做完字典的key，
  -value 可以为数字、列表、元祖、字典、字符串
• 字典无序
• 字典支持删除
• 不支持while循环，支持for循环，可迭代对象

#for循环默认循环所有的key
info = {'k1': 'string1', 'k2': 'string2', 'k3': 'string3', 'k4': 'string4'}
#默认循环key
for item in info:
    print(item)
#或者另一种写法
for item in info.keys():
    print(item)
#循环values
for item in info.values():
    print(item)
#key ，values 一起循环
for item in info:
   print(item ,info[item])
#另一种简单写法
for k,v in info.items():
    print(k,v)

字典的方法

• 1.清除 clear（）
• 2.拷贝 copy（）
• 3.根据序列，创建字典，并指定统一的值

#第一个值是key，第二值为values，如果没有第二个值，values默认为None，
v= dict.fromkeys(['k1','k2','k3'])
print(v)
#
s=dict.fromkeys(['k1','k2','k3'],99)
print(s)

• 4get，根据Key获取值，key不存在时，可以指定默认值（None）

#根据key取values，key不存在时候value默认111 
info ={'k1':99,'k2':100}
t = info.get('k3',111)
print(t)

• 4pop移除字典的值并获取这个值，如果删除的key不存在就获取后面跟的默认值

info ={'k1':99,'k2':100}
s = info.pop('k1'，111)
print(s,info)

• 5.setdefault，设置值，如果key已存在值，不设置获取当前key对应的值，不存在插入一个新的键值对

info ={'k1':99,'k2':100}
r= info.setdefault('k3','aaa')
print(r)
print(info)

• 6.update，更新(有的key，替换新的value，没有的key新插入一条)

#写法1
info ={'k1':99,'k2':100}
info.update({'k1': 999, 'k2': 1100,'k3':222})
print(info)
#写法1
info.update(k1=1222,k3=2222,k2=4444)
print(info)

常用：get、update、values()、keys()、items（）

6.布尔值bool

1.进行转换为布尔值
bool（...）
内存村委0和1
2.None，“”（空字符串）{}(空字典)，[]（空列表),（）（空元祖）， 0 ==>False

7.总结常用方法

• 一 数字

int（...）

• 二 字符串

replace/find/join/strip/startswith/split/upper/lower/format

tempalte='i am {name},age:{age}'
v=tempalte.format(name='alex',age=12)
#或者
v=tempalte.format({'name':'alex','age':19})
print(v)

• 列表

append/extend/insert
索引、切片、循环

• 元祖

索引、切片、循环 一级元素不能被修改

• 字典

get /update/keys/values/items
for循环,索引 in

#判断一个值是否在字典里默认循环key
dic ={'k1':'v1'}
v= 'k1'in dic
print(v)
#循环value用c.values()
v= 'k1'in dic.values()
print(v)