（八）变量及数据类型详解

数据类型

数字 （整形，浮点型，长整形（python2）,复数（python2））
字符串

字节串

列表

元组

字典

集合

一、数字

整形 int

作用：年龄，等级，身份证号码等

定义：age=10 等价于age=int(10)

浮点形 float

作用： 薪资，身高，体重等

weight=81.3 等价于 weight= float(81.3)

其他数字类型：

长整形

在Python2中存在， Python3中已经取消

>>> a=11111111111111111111111111111111111111111111111111111111111111111111111111
11111111
>>> print (type(a))

>>><type 'long'>

复数

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

二、字符串

作用： 姓名，性别等描述性信息
定义：在单引号，双引号，三引号内，由一串字符组成

name='bruce'  # name="bruce"   # name='''bruce'''

常见操作：

1， 按索引取值（正向取+反向取）:只能取

name='bruce'
print(name[0])

>>>b

msg='hell0 word'
print(msg[-2])

>>>r

msg[2]='A'
print(msg)

>>>TypeError: 'str' object does not support item assignment

2，移除字符 strip 只能去除字符串两边的字符，默认去掉的是左右两边的空格

name='**Bruce***'
print(name.strip('*'))

>>>Bruce
 

name='  #/           **Bruce***  #、'
print(name.strip())
print(name.strip('、'))

>>>#/           **Bruce***  #、
>>>  #/           **Bruce***  #

msg='***/ ***a**alex is somebody** / ///*'
print(msg.strip("* a /"))    #可以去掉多个字符，空格隔开

>>>lex is somebody

msg='***/ ***a**alex is somebody** / ///*'
print(msg.strip("* a /"))
print(msg.lstrip("*"))    #移除左边left指定字符
print(msg.rstrip("*"))    #移除右边right指定字符

>>>lex is somebody
>>>/ ***a**alex is somebody** / ///*
>>>***/ ***a**alex is somebody** / ///

3，切片 （顾头不顾尾，步长）

msg='hello world'
print(msg[0:4])  #步长默认是1
print(msg[0:4:2])# 步长是2

>>>hell
>>>hl

4，长度len #计算一个字符长度

msg='hello world'
print(len(msg))

>>>11

5, 成员运算in & not in

msg='bruce said bruce is free, can't be caged'
if 'bruce' in msg:
    print('yes')

>>>yes

6， split #将字符串转化为列表类型, 默认分隔符为空格

info='root:x:0:0::/root:bin/bash'
res=info.split(':')
print(res)
print(res[0])
print(info.split('/')[0]) 

>>>['root', 'x', '0', '0', '', '/root', 'bin/bash']
>>>root
>>>root:x:0:0::

dir="c:/a/b/c/d/1.txt"
print(dir.rsplit('/')[-1::-1])    #从右边开始切分

>>>['1.txt', 'd', 'c', 'b', 'a', 'c:']

inp='get a.txt'
cmd=inp[0:3]
filepath=inp[4:]
print(cmd)
print(filepath)
res=inp.split(' ')
print(res)

>>>get
>>>a.txt
>>>['get', 'a.txt']

7, 循环取值

a='int'
n=0
while n< len(a):
    print(a[n])
    n+=1

>>>
i
n
t

或者

for i in 'int':
    print(i)
    
>>>
i
n
t

8， 大小写 lower,upper

name='BrucE'
print(name.lower())
print(name.upper())

>>>bruce
>>>BRUCE

9, starts with/ ens with

ll='hello world'
print(ll.startswith('h'))
print(ll.endswith('d'))`

>>>True
>>>True

10, format 格式化输出

1）print('my name is %s my age is %s' %(18,'bruce'))

>>>my name is 18 my age is bruce     #需要记住顺序即对应关系

print('my name is {x} my age is {y}'.format(y=18,x='bruce') ) #无需记住顺序

>>>my name is bruce my age is 18

2）print('my name is {} my age is {}'.format(18,'bruce'))

>>>my name is 18 my age is bruce   #为空代表第一个值放到第一个空白处，以此类推，如果没有对应上则报错

3）print('my name is {1} my age is {0}  {1} {0}'.format(18,'bruce'))

>>>my name is bruce my age is 18  bruce 18

11，join #split的逆操作，将列表拼接成字符串，只能连接元素全都为字符串的列表

info='root:x:0:0::/root:bin/bash'
str_to_list=info.split(':')
print(str_to_list, type(str_to_list))

>>>['root', 'x', '0', '0', '', '/root', 'bin/bash'] <class 'list'>


L=['root', 'x', '0', '0', '', '/root', 'bin/bash']
list_to_str="/".join(L)
print(list_to_str,type(list_to_str))

>>>root/x/0/0///root/bin/bash <class 'str'>

12, replace

顾名思义，替换，将字符串中的某些老元素替换为新元素，而且可以定义替换几次,默认全部替换。

infomation='bruce add me，add her, add his in wechat'
res=infomation.replace('add',"added",1 )
print(res)

>>>bruce added me，add her, add his in wechat    #只替换一次

13, isdigit
用于判断是否为数字，结果为Ture 或者False

print('12312312'.isdigit())

>>>True

print('12312312abc'.isdigit())

>>>False

猜年龄游戏

while True:
    age=input('pls input the age: ').strip()
    if not age.isdigit():
        print('you must input the numbers')
        continue
    age=int(age)
    if age>30:
        print('too big')
    elif age==30:
        print('you get it')
        break
    elif age < 30:
        print('too small')

其他内置方法

• find,rfind,index,rindex,count

三、列表

用途： 存放多个值
定义方式：[ ] 内逗号分隔开多个元素，每个元素可以是任意数据类型,逗号隔开

list=['bruce','ailleen','daa','abc']

常用操作+内置方法：
1，按索引取值（正向取值+反向取值）既可以取也可以改

list=['bruce','ailien','daa','abc']
print(list[3])   #索引号从0开始依次递增，查第四个值,超出队列会报错

>>>abc

print(list[-2])   #反向取值，倒数第二个
 
>>>daa

list[1]='AAA'     #将第二个值更改为'AAA'
print(list)

>>>['bruce', 'AAA', 'daa', 'abc']

2, 切片（顾头不顾尾，步长）

list=['bruce','ailien','daa','abc']
print(list[0:3:2])   #定义取值范围和步长，从0到3，步长为2
pint(list[::2])     #未定义取值范围，默认所有，步长为2

>>>['bruce', 'daa']

print(lists[-1::-1])  #从倒数第一个开始，所有，步长-1，即倒序

>>> ['abc', 'daa', 'ailien', 'bruce']

3, 成员运算 in & not int

print('bruce'in lists)

>>>True

4, 长度运算

list=['bruce','ailien','daa','abc']
print(len(lists))

>>>5

5, 追加与插入

lists=['bruce','ailien','daa','abc']
lists.append('xxx')
print(lists)

>>>['bruce', 'ailien', 'daa', 'abc', 'xxx']

lists=['bruce','ailien','daa','abc']
lists.insert(3,'aaa')
print(lists)

>>>['bruce', 'ailien', 'daa', 'aaa', 'abc']

6, 删除列表中某一元素

del lists[1]  #将列表中第二个元素删除，不推荐
lists.remove('bruce')  #删除指定元素，推荐

从列表中取走一个元素

lists=['bruce','ailien','daa','abc']
res=lists.pop(3)
print(res)
print(lists)

>>>abc
>>>['bruce', 'ailien', 'daa']

7， 循环

names=['bru','ail','a',1,2,3,4]
for x in names:
    print(x)

>>>
bru
ail
a
1
2
3
4

四、元组

作用： 存多个值，不可变的列表，主要用来读
定义：与列表类型比，最不过 [ ] 换成 （）

age=(11,12,13,14)  #等同age=tuple((11,12,13,14))

常见操作

• 按索引取值（正向取+反向取）:只能取
• 切片（顾头不顾尾，步长）
• 长度len
• 成员运算in 和 not in

五、字典

作用： 存多个值，key:value格式存取。

定义：key必须是不可变类型 （数字，字符串，元组），value 可以是任意类型。key对value起解释说明作用，通常为字符串。
字典为可变类型，更改原值后id不变

d={'x':1}
print(id(d),d['x'])
d['x']=2
print(id(d),d['x'])

>>> 140603553117888 1
>>> 140603553117888 2

d['y']=3
print(id(d),d)

>>> 140341462001344 {'x': 2, 'y': 3}            #当元素不存在时，会自动添加。列表就会报错。

常见操作和内置方法

info={'name':'bruce',
      'age':18,
      'job':
          {'company':'newegg',
           'BU':'NESC',
           'Title':'NOC manager'
           }
      }

print(info['job']['Title'])
print(info['age'])

>>>NOC manager
>>>18

• len 长度

print(len(info))

>>>3

• 成员运算in 和not in 注意判断的是字典的key，不是value

print(18 in info)
print('job'in info)

>>>False
>>>True

• 删除

del info['age']             #万能的del，不推荐
print(info)

>>>{'name': 'bruce', 'job': {'company': 'newegg', 'BU': 'NESC', 'Title': 'NOC manager'}}

print(info.popitem())   #没有指定，随机删除, 返回结果是删除的键值，类型是元组类型

>>>('job', {'company': 'newegg', 'BU': 'NESC', 'Title': 'NOC manager'})

print(info)

>>>{'name': 'bruce', 'age': 18}    #上述键值已被删除


print(info.pop('name'))      #指定删除的key，并返回删除的value
print(info)                 #已经删除了’name'
print(info.pop('aaaaa','没有找到'))         #若指定键值不存在，则返回自定义的默认值

>>>bruce
>>>{'age': 18, 'job': {'company': 'newegg', 'BU': 'NESC', 'Title': 'NOC manager'}}
>>>没有找到

• 循环

while循环在列表，元组，字符串 里面的值都可以按照索引取值，字典中并无索引，只能用for循环。

for 只能拿key出来

msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
} 


for x in msg_dic:
    print(x)
    
>>>apple
    tesla
    mac
    lenovo
    chicken
    

如果想连同value一起拿，则需要

for x in msg_dic:
    print(x,msg_dic[x])

>>>apple 10         #返回为str类型
    tesla 100000
    mac 3000
    lenovo 30000
    chicken 10

• 键keys()，值values()，键值对items(), 返回一个值，该值包含了后面括号内的所有值。常与for循环一起使用

print(msg_dic.keys())

print(msg_dic.keys(),type(msg_dic.keys()))
print(msg_dic.values(),type(msg_dic.values()))
print(msg_dic.items(),type(msg_dic.items()))

>>>dict_keys(['apple', 'tesla', 'mac', 'lenovo', 'chicken']) <class 'dict_keys'>
>>>dict_values([10, 100000, 3000, 30000, 10]) <class 'dict_values'>
>>>dict_items([('apple', 10), ('tesla', 100000), ('mac', 3000), ('lenovo', 30000), ('chicken', 10)]) <class 'dict_items'>

与for一起搭配

取所有key值

for k in msg_dic.keys():        #默认字典取值就是key，所以该方法属于鸡肋
    print(k)
    
>>>apple
    tesla
    mac
    lenovo
    chicken

取所有value值

for v in msg_dic.values():
    print(v)

>>> 10
    100000
    3000
    30000
    10

取所有item值

for i in msg_dic.items():
    print(i)
    
>>>('apple', 10)
    ('tesla', 100000)
    ('mac', 3000)
    ('lenovo', 30000)
    ('chicken', 10)

以上取出的是元组形式，如果要单纯的取出k，v可这么赋值

for k,v in msg_dic.items():
    print(k,v)

>>>pple 10
    tesla 100000
    mac 3000
    lenovo 30000
    chicken 10

其他操作

• get 取key值用的，如果key值不存在，则返回none，可自定义返回值

info={'name':'bruce',
      'age':18,
      'job':
          {'company':'newegg',
           'BU':'NESC',
           'Title':'NOC manager'
           }
      }
print(info.get('age'))
print(info.get(111))
print(info.get(11111),'this vailue not exist')
>>>18
>>>None
>>>None this vailue not exist

• update 更新, 如果更新前有key值，以更新后的值为准，如果之前就没有key值，就新增

info={'name':'bruce',
      'age':18,
      'job':
          {'company':'newegg',
           'BU':'NESC',
           'Title':'NOC manager'
           }
      }
info.update({'age':19,'sex':'male'})    #将有值的age更新，并新增sex：male
print(info)

>>>{'name': 'bruce', 'age': 19, 'job': {'company': 'newegg', 'BU': 'NESC', 'Title': 'NOC manager'}, 'sex': 'male'}

• setdefault 如果key存在，则返回原有key值，如果key不存在，则新增key:value

x=info.setdefault('name','Morron')
y=info.setdefault('cname','Morron')
print(info)

>>>{'name': 'bruce', 'age': 18, 'job': {'company': 'newegg', 'BU': 'NESC', 'Title': 'NOC manager'}, 'cname': 'Morron'}

将列表L1中出现数字的个数统计出来

if...else实现

L1='1 2 3 1 2 5 3 1 '
word=L1.split()
d={}
for w in word:
    if w not in d:
        d[w]=1
    else:
        d[w]+=1
print(d)

>>>{'1': 3, '2': 2, '3': 2, '5': 1}

setdefault 实现

L1='1 2 3 1 2 5 3 1 '
word=L1.split()
d={}
for w in word:
    d.setdefault(w,word.count(w))
print(d)

>>>{'1': 3, '2': 2, '3': 2, '5': 1}

集合

作用：去重，关系运算

定义：可以包含多个元素，用逗号分隔

集合的元素遵循三个原则：

1. 每个元素都必须是不可变类型（数字，字符串，元组）
2. 没有重复的元素
3. 无序

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

常用操作及内置方法

• 长度len
• 成员运算in 和not in
• '|' 合集
• '&' 交集
• '-' 差集
• '^' 对称差集
• '=='等于
• '>,>=' 父集
• '<,<=' 子集

A={'a','b','c','d'}
B={'c','d','e','f'}

print(len(A))

>>>4

print(A|B)

>>>{'b', 'f', 'c', 'd', 'e', 'a'}

print(A&B)

>>>{'c', 'd'}

print(A-B)
print(B-A)

>>>{'b', 'a'}
>>>{'e', 'f'}

print(A^B)

>>>{'b', 'f', 'e', 'a'}

print(A==B)

print(A>=B)

print(A<=B)

>>>False
>>>False
>>>False