python 数据类型

一、数据

　　1.1 什么是数据

　　　　x=10，10是我们要存储的数据

　　1.2 为何数据要分不同的类型

　　　　数据是用来表示状态的，不同的状态就应该用不同的类型的数据去表示

　　1.3 数据类型

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

　　　　字符串

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

　　　　列表

　　　　元组

　　　　字典

　　　　集合

　　　　布尔（任何属性都自带布尔类型） True  False   bool()

　　1.4 按照以下几个点展开数据类型的学习

# 基本使用
    1 用途

    2 定义方式
    
    3 常用操作+内置的方法

# 类型总结
1 存一个值or存多个值
    只能存一个值
    可以存多个值，值都可以是什么类型

2 有序or无序

3 可变or不可变
    ！！！可变：值变，id不变。可变==不可hash
    ！！！不可变：值变，id就变。不可变==可hash

二、数字

　　2.1 整型与浮点型

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

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

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

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

　　2.2 其他数字类型（了解）

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

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

三、字符串

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

#定义：在单引号双引号三引号内，由一串字符组成
name='egon'
# name = str('egon')

#优先掌握的操作：
#1、按索引取值(正向取+反向取) ：只能取
#2、切片(顾头不顾尾，步长)
#3、长度len
#4、成员运算in和not in
#5、循环
#6、移除空白strip
#7、切分split

# 必须掌握
print(str[4])   # 返回4下标
print(str[-2])    # -2下标
print(str[222])    # 保错，超出下标

print(str[2:])  # 切片返回下标2之后的所有
print(str[-2:])   # 从-2下标至最后
print(str[-2::-1])  # 反向不长为-1  也就是从下标-2 一直倒序取到最后

print(len(str))   # 内置函数len 取 字符串的长度
print(not str)   # 任何数据类型都自带boolean 类型， 有为真无为假

for s in str:
    print(s)

strip(去除两边的指定字符)  lstrip(去除左边的指定字符)   rstrip(去除右边的指定字符)
print(str.strip('h'))  # 去除左右两边的'h'  ，不填写则默认去除两边的' '字符
print('   aaa   '.strip())

　　优先掌握

# 优先掌握
#1、strip,lstrip,rstrip
#2、lower,upper
#3、startswith,endswith
#4、format的三种玩法
#5、split,rsplit
#6、join
#7、replace

# 优先掌握
# lower(转小写方法)  upper(转大写方法)
# print('ASS'.lower())   # 返回小写
# print('aaa'.upper())   # 返回大写

# print(str.startswith('jmz'))   # 判断是否已'jmz'开头
# print(str.endswith('ah'))      # 判断是否已'ah'结尾

# format 三种玩法
# print('{} {} {}'.format('jmz',18,'man'))
# print('{1}{0}{1}'.format('jmz','---'))
# print('{name} {age} {name}-{sex}'.format(name='jmz',age=18,sex='man'))
'''
jmz 18 man
---jmz---
jmz 18 jmz-man
'''

# split rsplit
# print('jmz 18 man'.split())   # split 已什么方式分割字符串 并转成列表  默认从左切割，一直切到最后
# print('jmz 18 man'.rsplit( 'm',1))   # split 已什么方式分割字符串 并转成 列表， 从右切割，只切一次

# 将 列表类型装字符串类型
# print(''.join(['jmz','18', 'man']))  # 可迭代对象必须都是字符串

# print('this is a world'.replace('a','a beatiful',1))   # replace(self,old,new,count) 旧的字符转新字符，count 换几个
# 没有找到就旧字符就不转换

了解

# 1、find rfind index rindex count
# 2、center,ljust,rjust,zfill
# 3、expandtabs
# 4、capitalize
# 5、swapcase
# 6、title
# 7、is 数字系列（isdigit 必须掌握）
# 8、is其他系列

# 了解
find rfind index rindex count
print('shanghai shi yi ge hao di fan'.find('q',2,10))    # 找到 放回下标 ，没找到返回 -1
print('shanghai shi yi ge hao di fan'.rfind('f'))    # 从右开始找 找到 放回下标 ，没找到返回 -1
print('shanghai shi yi ge hao di fan'.index('q'))    # 有则返回下标 没找到则报错
print('shanghai shi yi ge hao di fan'.index('q'))    # 有则返回下标 没找到则报错
print('shanghai shi yi ge hao di fan'.rindex('f'))    # 从右开始  有则返回下标 没找到则报错
print('shanghai shi yi ge hao di fan'.count('q'))    # 返回字符串的个数

# center,ljust,rjust,zfill
print('jmz'.center(20,'-'))  # 共20个字符空间，'jmz' 居中。  如果'jmz'字符个数大于给定的字符个数则只显示jmz
# --------jmz---------

name='egon	hello	night'  # 	 表示一个tab的缩进
print(name)
print(name.expandtabs(0))   # str.expandtabs(tabsize=8)  tabsize 表示代表几个字符，默认8个字符


print('jmz is beatiful'.capitalize())   # 语句开头字母转大写
# Jmz is beatiful
print('jmz IS Beatiful'.swapcase())   # 字母大小写反转
#JMZ is bEATIFUL
print('jmz is beatiful'.title())    # 每一个单词的开头都是大写
#Jmz Is Beatiful



# is 数字系列
# isdigit isnumeric isdecimal
num1 = b'4' # bytes ascii
num2 = u'4' # unicode python3 默认unicode
num3 = '四'
num4 = 'Ⅳ'
# isdigit  只对unicode  和bytes  有用
print(num1.isdigit())  # True
print(num2.isdigit())  # True
print(num3.isdigit())  # False
print(num4.isdigit())  # False

# isnumeric 能够识别除bytes 意外的类型
# # print(num1.isnumeric())  # 报错
print(num2.isnumeric())  # True
print(num3.isnumeric())  # True
print(num4.isnumeric())  # True

# isdecimal 最严格 只对unicode 有效
# # print(num1.isdecimal())  # 报错
print(num2.isdecimal())  # True
print(num3.isdecimal())  # False
print(num4.isdecimal())  # False


# is其他系列
name = 'jmz'
print(name.isalpha())   # 是否由字母组成
print(name.isalnum())   # 是否由字母或数字组成
name = 'Jmz Is Cool'
print('dobi_123'.isidentifier()) # 判断是否为Python中的标识符  合法的变量名+关键字
print(name.islower())  # 是否是小写
print(name.isupper()) # 是否都大写
print(name.isspace()) # 检测字符串是否由空格组成
print('     '.isspace()) # True
print(name.istitle())  # 是否 单词开头大写

四、列表

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

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

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

#5、追加
#6、删除
#7、循环

# 必须掌握

names = ['jmz','qqc','llx','dd']
print(names[1:]) #['qqc', 'llx', 'dd']
print(names[:3]) # ['jmz', 'qqc', 'llx']
print(names[:-3:-1]) # ['dd', 'llx']   -1 反向步长
print(names[-2::-1]) #['llx', 'qqc', 'jmz']     -1 反向步长


print(len(names))

for name in names:
    print(name)

for k,v in enumerate(names):
    print('%s   %s'%(k,v))


if 'jjj' not in names:
    print('True')    #True


# 列表的增删改
# 增
names = []
print(id(names))    # id() 函数用于获取对象的内存地址。
names.append('kkk')
names.insert(2,'aa')
names.extend(['a','b','c'])   # 列表扩展
print(names)
print(id(names))

# 内存地址没有改变 ，说明值是可变的，也就是可变类型 == 不可hash

# 改
names[2] = 'eee'
print(names)

# 删
names.pop()   # 默认删除最后一个
print(names)
print(names.count('aa'))   # 查看 在里面的个数
names.clear()

五、元组

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

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

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

#5、循环

names = ('jmz',)  # names = tuple(('jmz',))
ages = (11,22,33,44)
print(names,type(names))
# 注意：
# 元组内只有一个数据时需要这样写  （一个数据,）   一定要加",", 如果没有则会时str类型


# 切片与列表一样


# 元组与列表很相似,只是不能像列表那样对数据进行增删改的操作.

六、字典

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

#定义：key必须是不可变类型，value可以是任意类型
info = {'name':'jmz','age':25,'sex':'man'}
# 与一下定义一样
# info = dict({'name':'jmz','age':25,'sex':'man'})
# info = dict(name='jmz',age=25,sex='man')
# info = dict([['name','jmz'],('age',25),['sex','man']])


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

# 
#4、增删改   setdefault update get pop popitem 
#5、键keys()，值values()，键值对items()
#6、循环

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author Jmz


info = {'name':'jmz','age':25,'sex':'man'}
# info = dict({'name':'jmz','age':25,'sex':'man'})
# info = dict(name='jmz',age=25,sex='man')
# info = dict([['name','jmz'],('age',25),['sex','man']])

# print(info,type(info))


for k in info:    # 循环key
    print(k,info[k])

'''
name jmz
age 25
sex man
'''
for k in info.keys():
    print(k)
'''
name
age
sex
'''
for v in info.values():
    print(v)
'''
jmz
25
man
'''
for v in info.items():
    print(v)
'''
('name', 'jmz')
('age', 25)
('sex', 'man')
'''

for k,v in info.items():
    print(k,v)
'''
name jmz
age 25
sex man
'''




print('和平的分割线'.center(100,'-'))

# 判断是否存在某个key,    in  | not in
if 'name' in info:
    print('存在name 这个key ')

print(len(info))





print('增删改    和平的分割线'.center(100,'-'))

# 增

info['school'] = '上海啦啦啦'
info.setdefault('obj','上海华为')    # 无责增加 ，有则不改
print(info)
#{'name': 'jmz', 'age': 25, 'sex': 'man', 'school': '上海啦啦啦', 'obj': '上海华为'}

# 改
info['school'] = '南京理工'
dic = {
    'name':'陌语',
    'age':18,
    'addr':'北京'
}

info.update(dic)   #    有则改之，无则增加

print(info)
#{'name': '陌语', 'age': 18, 'sex': 'man', 'school': '南京理工', 'obj': '上海华为', 'addr': '北京'}


# 删
info.pop('name')  # 知道删
info.popitem()    # 随机删
print(info)
# {'age': 18, 'sex': 'man', 'school': '南京理工', 'obj': '上海华为'}



# 查
if 'sex' in info:
    print('键存在')

print(info.get('obj'))   # 有则返回， 无则None

 七、集合

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

#定义：
　　info = {'jmz',12,('pinpan','biubiubiu')}   # 元素必须是不可变类型   
　　# info = set(['jmz',12,('pinpan','biubiubiu')])
  
#知识点回顾
     可变类型是不可hash类型
     不可变类型是可hash类型

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

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

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

#3、|合集
#4、&交集
#5、-差集
#6、^对称差集
#7、==
#8、父集：>,>= 
#9、子集：<,<=    

names1 = {'jmz','joe','jack','ming'}
# 集合不可变类型。
for name in names1:
    print(name)
'''
# 字典和集合一样都是无序的，所以出来的结果也是无序的
ming
jack
joe
jmz
'''

if 'jmz' in names1:
    print('jmz 在names1 中')




names2 = {'jmz','jack','vavain','king'}


print('集合运算'.center(100,'-'))
#3、|合集
#4、&交集
#5、-差集
#6、^对称差集
#7、==  等于
#8、父集：>,>=
#9、子集：<,<=

print(names1|names2)  # 两者的合集
# {'joe', 'ming', 'vavain', 'king', 'jack', 'jmz'}

print(names1&names2)  # 连个的交集
# {'jack', 'jmz'}

print(names1-names2)  # 去除names1 中含有names2 的数据
# {'ming', 'joe'}

print(names1^names2)  # 合集-交集
# {'vavain', 'joe', 'ming', 'king'}

print(names1 == names2)

print({'jmz','qqc'} > {'qqc'})   # 前者是后者的父集
# True
print({'jmz','qqc'} < {'qqc'})   # 前者不是后者的子集
#False

names = "jmz joe kitty nask egon jmz kitty qqc kitty vavian vavian"

# 方法一
name_l = names.split()
name_dic = {}
for name in name_l:
    if name in name_dic:
        name_dic[name] += 1
    else:
        name_dic[name] = 1

print(name_dic)

# 方法二
name_l = names.split()
name_dic = {}
for name in set(name_l):
    name_dic[name] = name_l.count(name)
print(name_dic)

八、运算符

is 与 == 的区别

is 比较的是数据的内存地址

== 比较的是数据是否相同

x = ['jmz','egon','vivian']

y = ['jmz','egon','vivian']

if x == y:
    print("x 与 y 的数据是相等的")

if x is y:
    print("x 与 y 的内存地址指向的是同一个地方")

print(id(x)) # id函数用于获取数据的内存地址
print(id(y))
# x，y 的内存地址是不一样的，但是数据确实相同的

特殊:相同的两个变量,内存地址一样?

x = 'jmz'
# 原理： 申请一个内存空间 用于保存'jmz' 数据，再申请一个名称空间用来保存变量名和数据的内存地址
y = 'jmz'

if x is y:
    print('x 与 y的内存地址是一样的')

# 造一个数据 赋值给 变量，应该每造一个数据就应该是另一个内存地址了，为什么上面的内存地址是一样的？
# 原因： python 内部机制的优化，如果重复造相同的小而短的数据，python 会自动指向同一个内存地址

九、总结

两大类型
　　1、可变类型:
   　　 在内存地址不变的情况下,可修改内部数据,即可变类型,目前有列表,字典

　　2、不可变类型:
   　　 在内存地址不变的情况下,不可修改内部数据,即不可变类型.目前有:整型,浮点型,字符串,元组,集合,复数


有序无序

　　1、有序:
　　　　字符串: 有序,自带有索引的
　　　　元组：有序，需要存索引相关信息，不可变
　　　　列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
　　2、 无序 (循环打印时,顺序是乱的)
　　　　集合：无序，即无序存索引相关信息
　　　　字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

info = bool('1')
print(info,type(info))

info1 = set(['jmz',12,('11',23,1)])    # set([元素])   每一个元素都必须是不可变类型，即可hash类型
print(info1,type(info1))

info2 = str(123.1)    # 集合类型内部必须是可hash 类型，即不可变类型
print(info2,type(info2))

info3 = int("1231")   # 内部必须是可以转化成整型的其他类型
print(info3,type(info3))

info4 = list([1,23,34,(1,2,3)])
print(info4,type(info4))

info5 = dict([('name','jmz'),('age',13)])
# info5 = dict(name='jmz',age=12)
# info5 = dict([['name','jmz'],['age',12]])
# info5 = dict({'name':'jmz','age':12})
print(info5,type(info5))

info6 = tuple((1,2,3))
# info6 = tuple([1,2,3])
# info6 = tuple({1,2,3})
print(info6,type(info6))


info7 = float(12)
# info7 = float('12')
print(info7,type(info7))

 本文取自:http://www.cnblogs.com/linhaifeng/articles/7133357.html#_label9