第2章 数据类型

 1.  什么是数据？

           x=2   2就是我们要存储的数据

2.  为何数据要用不同的类型

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

3.  数据类型

             数字（整型（int），长整型（long），浮点（float）,复数（complex））

             字符串

              列表

              元组

              字典

               集合

4.  数字（int，float，complex）

     作用：主要用于年龄，等级，薪资，号码等数字相关的。

     定义：

            age=10  #实质是age=int(10)

            salary=3000.3  #实质是salary=float(3000.3)

             数字可以进行转化，平常数字是十进制，可以转换为二进制，八进制，十六进制等。

      4.1 长整型

           在python2中有长整型的概念，python3中没有这个概念  

     

Python 2.7.5 (default, Nov  6 2016, 00:28:07) 
[GCC 4.8.5 20150623 (Red Hat 4.8.5-11)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> mun=3L
>>> type(mun)
<type 'long'>

      4.2  复数

     

>>> x=1-2j
>>> x.real 
1.0
>>> x.imag
-2.0

  5. 字符串

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

      定义：在单引号，双引号，3引号之类的，都称为字符串。例如：name='fang'

      常用操作：

             移除空白strip

             切分split

             长度len

             索引

             切片

              其他操作

#字符串移除空白strip
name='*****fanglingen*****'
print(name.strip('*'))    #移除*，默认是移除空白
print(name.lstrip('*'))   #移除左边的*
print(name.rstrip('*'))   #移除右边的*

#字符串分割split
name='root:x:0:0::/root:/bin/bash'
print(name.split(':'))     #默认以空格分割
print(name.split(':',1))   #以左边第一个：号为分割符，默认就是以左边数
name='a|b|c'
print(name.rsplit('|',1))  #以右边的第一个|号，为分隔符

#startswith,endswith字符串的开头和结尾
name='alex_SB'
print(name.endswith('SB'))    #判断字符串以什么结尾的真假
print(name.startswith('al'))  #判断字符串以什么开头的真假
#
# #字符串替换replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1)) #以第一个alex字符串替换为SB

# #format的三种玩法
res='{} {} {}'.format('fang',18,'male') #按顺序添加
res='{0} {1} {2}'.format('fang',18,'male') #按索引添加
res='{name} {age} {set}'.format(name='fang',age=18,set='male')
print(res)

#find,rfind,index,rindex,coun 按照字符查找索引
name='egon say hello'
print(name.find('o',1,3))  #顾头不顾尾，从左查找，找不到返回-1，找到显示索引
print(name.rfind('e',0,3)) #同上
# print(name.index('o',5,8))  #同上，找不到会报错
print(name.count('e',1,3)) #顾头不顾尾,如果不指定范围则查找所有

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

#center,ljust,rjust,zfill 字符串填充
name='egon'
print(name.center(30,'*'))  #字符串长度为30，字符串在中间，字符不够的填充*号
print(name.ljust(30,'*'))   #字符串靠左，长度为30，字符不够的填充*号
print(name.rjust(30,'*'))   #字符串靠右，长度为30，字符不够的填充*号
print(name.zfill(50))        #字符串长度为50，字符不够在左边填充0

#expandtabs 可以指定字符串之间的空格长度
name='egon	hello'
print(name)
print(name.expandtabs(1))

#lower,upper 字符串大小写转换
name='Egon'
print(name.lower())  #把字符串中的字符全部转换为小写
print(name.upper())  #把字符串中的字符全部转为大写

#captalize,swapcase,title
name='egon'
print(name.capitalize())  #首字母大写
print(name.swapcase())    #大小写翻转
msg='egon 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='egon123'
print(name.isalnum()) #字符串由字母和数字组成
print(name.isalpha()) #字符串只由字母组成

print(name.isidentifier())  #是否是合法标识符
print(name.islower())       #是否是小写
print(name.isupper())       #是否全是大写
print(name.isspace())       #是否只包含空白字符
print(name.istitle())       #是否是每个词首字母大写的字符串

     练习

# 写代码,有如下变量,请按照要求实现每个功能 （共6分，每小题各0.5分）
name = " aleX"
# 1)    移除 name 变量对应的值两边的空格,并输出处理结果
# 2)    判断 name 变量对应的值是否以 "al" 开头,并输出结果

# 3)    判断 name 变量对应的值是否以 "X" 结尾,并输出结果

# 4)    将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
# 5)    将 name 变量对应的值根据 “l” 分割,并输出结果。
# 6)    将 name 变量对应的值变大写,并输出结果

# 7)    将 name 变量对应的值变小写,并输出结果

# 8)    请输出 name 变量对应的值的第 2 个字符?
# 9)    请输出 name 变量对应的值的前 3 个字符?
# 10)    请输出 name 变量对应的值的后 2 个字符?

# 11)    请输出 name 变量对应的值中 “e” 所在索引位置?

# 12)    获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。

name = " aleX"
# 1)    移除 name 变量对应的值两边的空格,并输出处理结果
print(name.strip())
# 2)    判断 name 变量对应的值是否以 "al" 开头,并输出结果

print(name.startswith('al'))
# 3)    判断 name 变量对应的值是否以 "X" 结尾,并输出结果

print(name.endswith('X'))
# 4)    将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
print(name.replace('l','p'))
# 5)    将 name 变量对应的值根据 “l” 分割,并输出结果。
print(name.split('l'))
# 6)    将 name 变量对应的值变大写,并输出结果

print(name.upper())
# 7)    将 name 变量对应的值变小写,并输出结果

print(name.lower())
# 8)    请输出 name 变量对应的值的第 2 个字符?
print(name[1])
# 9)    请输出 name 变量对应的值的前 3 个字符?
print(name[0:3])
# 10)    请输出 name 变量对应的值的后 2 个字符?

print(name[-2:])
# 11)    请输出 name 变量对应的值中 “e” 所在索引位置?

print(name.find('e'))
# 12)    获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。
print(name[:-1])

 6. 列表

    作用：多个装备，多个属性等

    定义：[ ] 中可以有多个任意类型的值，以逗号分割

           l=['b','b','c']   #实质是l=list(['a','b','c'])  或者l=list('abc')

    常用操作

           索引

           切片

           追加

           删除

           长度

           循环

           包含in

my_girl_friends=['alex','wupeiqi','yuanhao',4,10,30]
#按照索引查找
print(my_girl_friends[0])

#追加
my_girl_friends.append('oldboy')
print(my_girl_friends)

#切片
print(my_girl_friends[1:3])

#删除 （remove按照值,pop按照索引）
#remove按照值删除
my_girl_friends.remove('alex')
print(my_girl_friends)

#pop按照索引删除
my_girl_friends.pop()
my_girl_friends.pop(1)

#len长度,有几个元素
print(len(my_girl_friends))

#insert插入，在那个索引之前插入
my_girl_friends.insert(1,'Sb')
print(my_girl_friends)

# #清空列表
my_girl_friends.clear()
print(my_girl_friends)

#拷贝列表
l=my_girl_friends.copy()
print(l)

#查看某个元素的个数
print(my_girl_friends.count('alex'))

#extend把多个元素以列表的形式添加到列表中
my_girl_friends.extend(['oldboy1','oldboy2','oldboy3'])
print(my_girl_friends)

index查看元素在列表中的索引
my_girl_friends.index('alex')
print(my_girl_friends.index('al'))

#reverse列表中的元素位置翻转
my_girl_friends.reverse()
print(my_girl_friends)

#sort排序
l=[3,-1,5,2]
#从大到小排列
l.sort(reverse=True)
print(l)
#从小到大排列
l.sort(reverse=False)
print(l)

           练习

                   有列表data=['alex',49,[1900,3,18]]分别取出列表中的姓名，年龄，出生年，月，日赋值给不同的变量

data=['alex',49,[1900,3,18]]
name=data[0]
age=data[1]
year=data[2][0]
month=data[2][1]
day=data[2][2]
print("name :",name,"age :",age,"calculate_age: ",year,"年",month,"月",day,"日")

           模拟队列 （先进先出）

l=['a','b','c','d']
l.append('e')
l.pop(0)
print(l)
l.pop(0)
print(l)
l.pop(0)
print(l)
l.pop(0)
print(l)

           模拟堆栈  （先进后出）

l=['a','b','c','d']
l.append('e')
l.pop(-1)
print(l)
l.pop(-1)
print(l)
l.pop(-1)
print(l)
l.pop(-1)
print(l)

 7. 元组

     作用：存多个值，对比列表来说，不可变，主要用来读

     定义：与列表类似，[]换成()

      可以当作字典的key

      age=(11,22,33,44,55)  #实质是age=tuple((11,22,33,44,55))

      常用操作

          索引

          切片

          追加

          删除

          长度

          循环

          包含in

data=(11,22,33,44,55,66,77,88,99)
#查看元素的索引
print(data.index(11))

#查看元素的数量
print(data.count(11))

#按照索引切片，得到一个新元组
print(data[3:5])

#查看元组里的元素个数
print(len(data))

#循环元组
for n in data:
    print(n)

#包含in
print(22 in data)

      练习 ：简单购物车

      实现打印商品的详细信息，用户输入商品名和个数，则将商品名，价格，个数加入购物列表，如果，输入为空或其他非法信息，要求用户重新输入。

      msg_dic={

       'apple' :10

       'tesla' :100000

       'mac' :3000

       'lenovo' :30000

       'chichen' :10

       }

msg_dic={
       'apple' :10,
       'tesla' :100000,
       'mac' :3000,
       'lenovo' :30000,
       'chichen' :10
}
goods_l=[]
while True:
    for key,itme in msg_dic.items():
        print('name:{name} price:{price}'.format(name=key,price=itme))
    choic = input('请输入商品名：').strip()
    if not choic or choic not in msg_dic.keys():continue
    conut=input('请输入购买商品数量：').strip()
    if not conut.isdigit():continue
    goods_l.append((choic,msg_dic[choic],conut))
    print(goods_l)

8. 字典

     作用：存放多个值，key-valuec存取，取值速度快

     定义：key是不可变的类型，value可以是任意类型

info={'name':'egon','age':18,'sex':'male'} #本质info=dict({....})
或
info=dict(name='egon',age=18,sex='male')
或
info=dict([['name','egon'],('age',18)])  #只能多个key对应一个value
或
print({}.fromkeys(('name','age','sex'),None))  #可以设置key的初始值

     常用操作：

           存/取

           删除

           键s, 值s     键值对

           长度

           循环

           包含in

info={'name':'egon','age':18,'sex':'male'}
#删除
print(info.pop('name'))         #删除key，value
print(info)
print(info.pop('dadfafdadf',None))  #删除不存在的key,value不报错

print(info.popitem())  #删除随机删除key,value
print(info.popitem())
print(info)
#取值
print(info['name'])
print(info.get('name'))
print(info.get('dafdaf',None))     #取值，查找不存在的key的值，不报错

#循环
print(info.keys(),type(info.keys()))
print(info.values())

for key in info.keys():
    print(key)

for key in info.values():
    print(key)

for key in info:
    print(key,info[key])

print(info.items())
for key,value in info.items(): # key,value=('name','egon')
    print(key,value)

#合并字典，key相同的，会把key的值变为新字典中的值
print(info)
dic={'a':1,'b':2,'name':'SHUAI'}
info.update(dic)
print(info)

#添加字典中的key和value
d={}
print(d)
d['name']='egon'
d['age']=18
d['sex']='male'
d['hobby']=[]
d['hobby'].append('play basketball')
d['hobby'].append('play football')

d.setdefault('hobby',[]).append('play1') #d['hobby']
d.setdefault('hobby',[]).append('play2') #d['hobby']
d.setdefault('hobby',[]).append('play3') #d['hobby']
print(d)

          练习

          1.   有下列集合[11,22,33,44,55,66,77,88,99,90] ，将所有大于66的值保存在k1中，将小于66的值保存在k2中

          即 {k1: 大于66的值，k2:小于66的值}

data=[11,22,33,44,55,66,77,88,99,90]
s1=[]
s2=[]
for itme in data:
    if itme >= 66:
        s1.append(itme)
    else:
        s2.append(itme)
print({"k1":s1,"k2":s2})

a={'k1':[],'k2':[]}
c=[11,22,33,44,55,66,77,88,99,90]
for i in c:
    if i>66:
        a['k1'].append(i)
    else:
        a['k2'].append(i)
print(a)

          2. 统计s='hello alex alex say hello sb sb'中的每个单词的个数

           结果如：{‘hello’ ：2，‘alex’：2，‘say’：1，‘sb’：2}

s='hello alex alex say hello sb sb'
data={}
for item in s.split():
    if not item in data.keys():
        data[item]=1
    else:
        data[item]+=1
print(data)

9. 集合

    作用：去重，关系运算

    定义：由不同元素组成的的集合，集合是一种无序排列的可hash值，可以当作字典的key

              集合的目的是将不同的值存放在一起，不同的集合间用来做关系运算，不必纠结集合中单个值

    常用方法：

              in 和not in

              |合集

              &交集

              -差集

              ^对称差集

              ==

              >,>= ,<,<= 父集，子集

       练习

              一· 关系运算：

              有一下2个集合，pythons是报名python班的学员的集合，linuxs是报名linux班的学员集合

              pythons=('alex','egon','wupeiqi','yuanhao','gangdan','biubiu')

              linuxs=('wupeiqi','oldboy','gangdan')

              1.求出即报名python又报名linux的学员集合

              2.求出所有的学员集合

              3.求出只报名python的学员集合

              4.求出没有同时报名的学员集合      

pythons = {'alex','egon','wupeiqi','yuanhao','gangdan','biubiu'}
linuxs = {'wupeiqi','oldboy','gangdan'}
# 1.求出即报名python又报名linux的学员集合
print(pythons & linuxs)
# 2.求出所有的学员集合
print(pythons | linuxs)
# 3.求出只报名python的学员集合
print(pythons - linuxs)
# 4.求出没有同时报名的学员集合
print(pythons ^ linuxs)

             二·去重：

              1.有列表l=['a','b',1,'a','a'],列表内的元素均为可hash类型，去重，新列表无需保持列表原来的顺序。

              2.在上题的基础上保持列表原来的顺序

              3.有如下列表，列表内的元素均为不可hash的类型，去重，新列表保持原来的顺序。

l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]

#1.有列表l=['a','b',1,'a','a'],列表内的元素均为可hash类型，去重，新列表无需保持列表原来的顺序
l=['a','b',1,'a','a']
print(set(l))

#2.在上题的基础上，保存列表原来的顺序
#不用集合
new_l=[]
for item in l:
    if item not in new_l:
        new_l.append(item)
print(new_l)

#用集合
l1=[]
s=set()
for item in l:
    if item not in s:
        s.add(item)          #添加元素到元组
        l1.append(item)
print(l1)
#3.有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序
l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'}
]
s=set()
l1=[]
for itme in l:
    val=(itme['name'],itme['age'],itme['sex'])
    if val not in s:
        s.add(val)
        l1.append(itme)
print(l1)

 10. 数据类型总结：

 

 11.运行符

      成员运算（in not in ）

      身份运算（is not is）

      详细http://www.cnblogs.com/fanglingen/articles/7131469.html

12.文件处理

#user文件内容
test1|test1123|0
test2|test2123|0
test3|test3123|0
test4|test4123|0
test5|test5123|0

f1=open('user.txt','r')
data =f1.read()    #把整个文件当作字符串来读
f1.close()         #关闭文件
# print(data)
user_info = []
user_str_info = data.split('
')
for item in user_str_info:
    temp = item.split('|')
 #   print(temp[2])
    v ={
      'name': temp[0],
      'pwd':temp[1],
      'times':temp[2]
    }
    user_info.append(v)
print(user_info)