python 字节数据组

基本数据类型

• 基本数据类型
• 整型
• 字符串
• 列表
• 元组
• 字典
• 集合
• 数据类型总结
• 运算符

 

 

一、基本数据类型

　　数字（整形，长整形，浮点型，复数）

　　字符串

　　字节串：在介绍字符编码时介绍字节bytes类型

　　列表

　　元组

　　字典

　　集合

二、整型

整型与浮点型

#整型int
　　作用：年纪，等级，身份证号，qq号等整型数字相关
　　定义：
　　　　age=10 #本质age=int(10)

#浮点型float
　　作用：薪资，身高，体重，体质参数等浮点数相关

    salary=3000.3 #本质salary=float(3000.3)

#二进制，十进制，八进制，十六进制

其他数字类型（了解）

#长整形（了解）
    在python2中（python3中没有长整形的概念）：　　　　　　
    >>> num=2L
    >>> type(num)
    <type 'long'>

#复数（了解）　　
    >>> x=1-2j
    >>> x.real
    1.0
    >>> x.imag
    -2.0

三、字符串

#作用：名字，性别，国籍，地址等描述信息

#定义：在单引号\双引号\三引号内，由一串字符组成
name='lee'

#优先掌握的操作：
按索引取值(正向取+反向取) ：只能取
切片(顾头不顾尾，步长)
长度len
成员运算in和not in


移除空白strip
切分split
循环

其他操作（包括常用）

#strip
name='*lee**'
print(name.strip('*'))
print(name.lstrip('*'))#移除左变的指定字符
print(name.rstrip('*'))#移除右边的指定字符

#startswith,endswith
name='dabaoshiwoerzi'
print(name.endswith('zi'))#以某个字符结尾
print(name.startswith('dabao'))#以某个字符开头

#replace
name='lee is handsome boy'
print(name.replace('boy','girl',1))#修改指定字符

#format的三种玩法
res='{} {} {}'.format('lee',20,'male')#类似于占位符
res='{1} {0} {1}'.format('lee',20,'male')#可以指定索引占位
res='{name} {age} {sex}'.format(sex='male',name='lee',age=20)#指定变量占位

#find,rfind,index,rindex,count
name='lee say hello'
print(name.find('o',1,3)) #顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引
# print(name.index('e',2,4)) #同上,但是找不到会报错
print(name.count('e',1,3)) #顾头不顾尾,如果不指定范围则查找所有


#split
name='root:x:0:0::/root:/bin/bash'
print(name.split(':')) #默认分隔符为空格
name='C:/a/b/c/d.txt' #只想拿到顶级目录
print(name.split('/',1))

name='a|b|c'
print(name.rsplit('|',1)) #从右开始切分


#join
tag=' '
print(tag.join(['lee','say','hello','world'])) #可迭代对象必须都是字符串

#center,ljust,rjust,zfill
name='lee'
print(name.center(30,'*'))#宽度30，已*填充居中
print(name.ljust(30,'*'))#宽度30，右边填充*
print(name.rjust(30,'*'))#宽度30，左变填充*
print(name.zfill(50)) #用0填充


#expandtabs
name='lee\thello'
print(name)#默认\t为四个空格
print(name.expandtabs(1))#指定为1个空格

#lower,upper
name='lee'
print(name.lower())#改为小写
print(name.upper())#改为大写


#captalize,swapcase,title
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
msg='lee say hi'
print(msg.title()) #每个单词的首字母大写

#is数字系列
#在python3中
num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字

#isdigt:bytes,unicode
print(num1.isdigit()) #True
print(num2.isdigit()) #True
print(num3.isdigit()) #False
print(num4.isdigit()) #False


#isdecimal:uncicode
#bytes类型无isdecimal方法
print(num2.isdecimal()) #True
print(num3.isdecimal()) #False
print(num4.isdecimal()) #False

#isnumberic:unicode,中文数字,罗马数字
#bytes类型无isnumberic方法
print(num2.isnumeric()) #True
print(num3.isnumeric()) #True
print(num4.isnumeric()) #True


#三者不能判断浮点数
num5='4.3'
print(num5.isdigit()) 
print(num5.isdecimal())
print(num5.isnumeric())
'''
总结:
    最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
    如果要判断中文数字或罗马数字,则需要用到isnumeric
'''

#is其他
print('===>')
name='lee123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成

print(name.isidentifier())
print(name.islower())
print(name.isupper())
print(name.isspace())
print(name.istitle())

　　

#作用：多个装备，多个爱好，多门课程，多个女朋友等

#定义：[]内可以有多个任意类型的值，逗号分隔
my_girl_friends=['bingbing_fan','bingbing_li','showgirl',4,5] #本质my_girl_friends=list([...])
或
l=list('abc')

#优先掌握的操作：
按索引存取值(正向存取+反向存取)：即可存也可以取      
切片(顾头不顾尾，步长)
长度
成员运算in和not in

l1 = ['a',1,2,'b'] l2 = [1,2,3,4]

l1.append('c')          #追加,在最后追加一个指定元素
l1.insert()             #插入,第一个参数为索引,可以指定插入的位置
l1.extend('lee')        #扩展,迭代添加(遍历添加)  res>>:['a', 1, 2, 'b', 'l', 'e', 'e']
l1+l2                   #列表合并               res>>:['a',1,2,'b',1,2,3,4]
l1 * 2                  #列表相乘,只能乘以整型     res>>:['a',1,2,'b','a',1,2,'b']
l1.remove('a')          #删除指定元素
l1.pop()                #弹出,默认删除最后一个元素,可以通过索引删除指定位置的元素,这个元素当做返回值
l1.clear()              #清空,清空列表中所有元素
del l1[0]               #通过del方法删除列表中的对应元素  注:del一般用来删除变量
l1[0] = 'lee'           #可以通过赋值的方法修改列表中的对应元素
l1[0:5] = 'asdf'        #可以通过切边的方式遍历修改指定位置的元素  注:切片指定的数量和添加的数量可以不一致
#列表的其他操作
l1.count('a')           #统计指定元素在列表中的数量
l1.index('a')           #查找指定元素在列表中的索引
l1.reverse()            #反转,列表中的元素顺序颠倒
l1.sort()               #排序,默认是升序(从小到大)
l1.sort(reverse=True)   #sort和reverse连用
l1.copy()               #拷贝出一个一模一样的列表

#ps:反向步长
l=[1,2,3,4,5,6]

#正向步长
l[0:3:1] #[1, 2, 3]
#反向步长
l[2::-1] #[3, 2, 1]
#列表翻转
l[::-1] #[6, 5, 4, 3, 2, 1]

#作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读

#定义：与列表类型比，只不过[]换成()
age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))

#优先掌握的操作：
按索引取值(正向取+反向取)：只能取   
切片(顾头不顾尾，步长)
长度
成员运算in和not in


循环

六、字典

#作用：存多个值,key-value存取，取值速度快

#定义：key必须是不可变类型，value可以是任意类型
info={'name':'lee','age':18,'sex':'male'} #本质info=dict({....})
或
info=dict(name='lee',age=18,sex='male')
或
info=dict([['name','lee'],('age',18)])
或
{}.fromkeys(('name','lee','sex'),None)

#优先掌握的操作：
按key存取值：可存可取
长度len
成员运算in和not in


删除
键keys()，值values()，键值对items()
循环

练习

#统计s='hello lee lee say hello sb sb'中每个单词的个数
#结果如：{'hello': 2, 'lee': 2, 'say': 1, 'sb': 2}
s='hello lee lee say hello sb sb'

l=s.split()
dic={}
for item in l:
    if item in dic:
        dic[item]+=1
    else:
        dic[item]=1
print(dic)

#利用setdefault解决重复赋值
'''
setdefault的功能
1：key存在，则不赋值，key不存在则设置默认值
2：key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值
d={}
print(d.setdefault('a',1)) #返回1

d={'a':2222}
print(d.setdefault('a',1)) #返回2222
'''
s='hello lee lee say hello sb sb'
dic={}
words=s.split()
for word in words: #word='alex'
    dic.setdefault(word,s.count(word))
    print(dic)



#利用集合，去掉重复，减少循环次数
s='hello lee lee say hello sb sb'
dic={}
words=s.split()
words_set=set(words)
for word in words_set:
    dic[word]=s.count(word)
    print(dic)

七、集合

#作用：去重，关系运算，

#定义：
            知识点回顾
            可变类型是不可hash类型
            不可变类型是可hash类型

#定义集合:
            集合：可以包含多个元素，用逗号分割，
            集合的元素遵循三个原则：
             1：每个元素必须是不可变类型(可hash，可作为字典的key)
             2:没有重复的元素
             3：无序

注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
 

#优先掌握的操作：
长度len
成员运算in和not in


|合集
&交集
-差集
^对称差集
==
>，>= ，<,<= 父集，子集

八、数据类型总结

数字 字符串 集合：无序，即无序存索引相关信息

元组：有序，需要存索引相关信息，不可变 列表：有序，需要存索引相关信息，可变，需要处理数据的增删改

字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

 

九、运算符

#身份运算（is ，is not）
is比较的是id，而双等号比较的是值
毫无疑问，id若相同则值肯定相同，而值相同id则不一定相同
>>> x=1234567890
>>> y=1234567890
>>> x == y
True
>>> id(x),id(y)
(3581040, 31550448)
>>> x is y
False