第三章.数据类型

3.1 整型（int）

• 整型的长度

  py2：int/long

  py3：int

• 整除

  py2：做整除后商只保留整数

  py3：做整除后商保留全部

3.2 布尔值（bool）

布尔值用于表示真假，只有两种结果True/False

转换问题

• str --->bool 只有""为False，其他均为True

• int --->bool 只有0为False，其他均为True

• list--->bool 只有[]为False，其他均为True

• tuple--->bool 只有()为False，其他均为True

• dict--->bool 只有{}为False，其他均为True

• set--->bool 只有set()为False，其他均为True

• None--->bool 为False

3.3 字符串（str）

3.3.1字符串的特有方法

字符串是写代码中最常见的，reduce

1.变大写 upper

v = "alexALEX"
v1 = v.upper()
print(v1)
v2 = v.isupper()  #判断是否全部大写
print(v2)

2.变小写 lower

v = "alexALEX"
v1 = v.lower()
print(v1)
v2 = v.islower()  #判断是否全部小写
print(v2)

3.判断是否为数字 isdecimal

以后推荐用 isdecimal 判断是否是10进制的数。

v = '1'
# v = '二'
# v = '②'
v1 = v.isdigit()   # '1'-> True; '二'-> False; '②' --> True
v2 = v.isdecimal() # '1'-> True; '二'-> False; '②' --> False
v3 = v.isnumeric() # '1'-> True; '二'-> True; '②' --> True
print(v1,v2,v3)

4.分割 split

v = "alexALEX"
b = v.split('l')
print(b)    #['a', 'exALEX']切割后得到的是一个列表

v = "alexALEX"
b = v.rsplit('l')
print(b) 

5.替换 replace

v = "alexALEX"
b = v.replace('l','*')
print(b)

6.去空格/ 去换行\n /去制表符\t /去指定字符串 strip

• 去空格

  v = "       alexALEX          "
  v1 = v.strip()  #去全部空格
  print(v1)
  v2 = v.lstrip()  #去左边空格
  print(v2)
  v3 = v.rstrip()  #去右边空格
  print(v3)
  

• 去换行\n

  v2 = "alex\nqwer\n"
  print(v2)  #alex    qwer
  ​

• 去制表符\t

  制表符\t：在字符串中使用，一般放在文章开头，做缩进用

  v3 = "\talex"
  print(v3.strip())

• 去指定字符串

  去掉字符串两边所有a和l

  v4 = "aldaexaaall"
  print(v4.strip('al'))  #daex

7.以某某开头startswith

name = 'qwertyuiop'
if name.startswith('qw'):
    print(name)

8.以某某结尾endswith

name = 'qwertyuiop'
if name.endswith('qw'):
    print('是')
else:
    print('不是')

9.占位符format

name = '我叫{}，年龄：{}'.format('老男孩',73)
print(name)

10.编码encode

name = '张三'
v = name.encode('gbk')
print(v)

11.添加join

name = 'qwertyuiop'
v = '_'.join(name)
print(v)   #q_w_e_r_t_y_u_i_o_p

name = ['qwertyuiop',1,2]     #name中含有数字和字符串
name2 = []
for item in name:
    name2.append(str(item))
v = '_'.join(name2)     #要想使用join，列表/集合内部必须全为字符串
print(v) 

name = {'k1':'1','k2':'2'}
v = '_'.join(name)   #默认取字典的键
print(v)   #k1_k2

12.其他

3.3.2字符串格式化

• %s：可代表所有数据类型

  #法一:
  msg = "我是%s,年龄%s" %('alex',19,)
  print(msg)
  #法二:
  msg = "我是%(n1)s,年龄%(n2)s" % {'n1': 'alex', 'n2': 123, }
  print(msg)
  #法三:
  # v2 = "我是{name},年龄{age}".format(name='alex',age=18)
  #法四:
  v2 = "我是{name},年龄{age}".format(**{'name':'alex','age':18})
  print(v2)

• %d:专门代表整型

• \n换行符

3.4列表（list）

列表中可以有字符串，整数，布尔，列表，元组，字典，集合，None。列表是有序的，可重复，列表是可变的。

1.append

在列表最后一个元素后追加一个元素，该元素可以是字符串，整数，布尔，列表，元组，字典，集合，None

user = ['q','w',1]
v = {1,2,3,4}
user.append(v)
print(user)   #['q', 'w', 1, {1, 2, 3, 4}]

2.insert

在指定位置添加一个元素

user = ['q', 'w', 1, {1, 2, 3, 4}]
user.insert(0,666)
print(user)

3.remove

只是移除，移除的后面加的是列表中元素

user = ['q', 'w', 1, {1, 2, 3, 4}]
user.remove('w')
print(user)

4.pop

移除，删除后将这个被删除的值赋给另一变量，pop后加入的是索引位置

user = ['q', 'w', 1, {1, 2, 3, 4}]
data = user.pop(1)
print(user)

5.clear

清空，运行后得到的是一个空列表

user = ['q', 'w', 1, {1, 2, 3, 4}]
user.clear()
print(user)   #[]

6.extend （）

将括号里面的元素循环添加到前面

v1 = ['q', 'w', 1]
v2 = {1, 2, 3, 4}
v1.extend(v2)
print(v1)

7.reverse 反转

v = [11,22,33,124,55]
v.reverse()
print(v)

8.sort 排序

v = [11,22,33,124,55]
v.sort()    #v.sort(reverse=False)从小到大（默认）
print(v)    #v.sort(reverse=True)从大到小

3.5元组（tuple）

元组是不可变的

3.6字典（dict）

字典是可变的，无序

info = {"name":'张三','age':18,'gender':'男','hobby':'打球'}
for item in info:
    print(item)        #默认得到的是字典的所有键

1.keys 取所有键

info = {"name":'张三','age':18,'gender':'男','hobby':'打球'}
for item in info.keys():
    print(item)        #得到的结果是一个个字符串

2.values 取所有值

info = {"name":'张三','age':18,'gender':'男','hobby':'打球'}
for item in info.values():
    print(item)       #得到的结果是一个个字符串

3.items 取所有键值对

info = {"name":'张三','age':18,'gender':'男','hobby':'打球'}
for item in info.items():
    print(item)
#('name', '张三')
#('age', 18)
#('gender', '男')
#('hobby', '打球')    得到的结果是一个个元组

4.update 字典中存在添加的字典中的键就更新，不存在就添加

info = {"name":'张三','age':18,'gender':'男','hobby':'打球'}
info.update({'age':19})
print(info)     #{'name': '张三', 'age': 19, 'gender': '男', 'hobby': '打球'}

info = {"name":'张三','age':18,'gender':'男','hobby':'打球'}
info.update({'身高':178})
print(info)     #{'name': '张三', 'age': 18, 'gender': '男', 'hobby': '打球', '身高': 178}

5.get

获取字典中该键对应的值，如果字典中不存在该键，就输出None，

info = {"name":'张三','age':18,'gender':'男','hobby':'打球'}
v = info.get('k1111')
print(v)      #None

如果获取字典中该键对应的值，如果字典中不存在该键，就输出后面的值

info = {'K1':'V1','K2':'V2','K3':'V3'}
v1 = info.get('k1111',666)
print(v1)    #666

6.pop

删除后将该删除的值赋给另外一值

info = {'K1':'V1','k2':'V2','K3':'V3'}
v = info.pop('k2')
print(info,v)   #{'K1': 'V1', 'K3': 'V3'} V2

7.有序字典

字典是无序的,但可以通过导入模块让其有序

from collections import OrderedDict
info = OrderedDict()
info['k1'] = 123
info['k2'] = 456
print(info.keys())
print(info.values())
print(info.items())

from collections import OrderedDict
odic = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(odic)
for k in odic:
    print(k,odic[k])

3.7集合（set）

集合里面的元素都是不可变类型，可添加字符串，整型，布尔，元组，None

1~3是对集合本身进行操作

1.add 添加

info = {'K1','k2','K3'}
info.add('v1')
print(info)   #{'v1', 'k2', 'K1', 'K3'}

2.update 更新

info = {'K1','k2','K3'}
info.update({1,2,3,(4,5)})
print(info)   #{1, 2, 3, (4, 5), 'k2', 'K1', 'K3'}

3.discard 删除

info = {'K1','k2','K3'}
info.discard('K1')
print(info)   #{'k2', 'K3'}

4.union 并集

v1 = {1,2,'张三'}
v2 = {1,2,'李四'}
result = v1.union(v2)
print(result)   #{'张三', 1, 2, '李四'}

5.intersection 交集

v1 = {1,2,'张三'}
v2 = {1,2,'李四'}
result = v1.interestion(v2)
print(result)   #{1,2}

6.difference 差集

v1 = {1,2,'张三'}
v2 = {1,2,'李四'}
result1 = v1.difference(v2)
print(result1)     #{'张三'}
result2 = v2.difference(v1)
print(result2)     #{'李四'}

7.pop

8.symmetric_difference(对称差分)

3.8 字节(bytes)

字节类型

3.9深浅拷贝

• 浅拷贝:浅拷贝就是拷贝第一层

• 深拷贝：深拷贝就是拷贝嵌套层次中所有可变类型

3.10公共功能

• 索引：（int，bool，set除外）

• 切片：（int，bool，set除外）

• 步长：（int，bool，set除外）

• len：（int，bool除外）

  • str ：字符串长度

  • list：列表内元素个数

  • tuple：元组内元素个数

  • dict：字典内键值对个数

  • set：集合内元素个数

  v = 'qwertyuiop'
  print(len(v))     #10

• for循环（int，booi除外）

• del（str，int，booi，tuple，set除外）

• 修改（str，int，bool，tuple，set除外）

3.11嵌套

 

3.12内存相关

• 内部修改

  v1 = [11,22,33]
  v1.append((44,55))
  print(v1)     #[11, 22, 33, (44, 55)]

• 赋值

  v1 = [11,22,33]
  v2 = v1
  v1 = [1,2,3,4]
  print(v2)       #[11,22,33]

• 查看内存地址

  v1 = [11,22,33]
  v2 = v1
  print(id(v1),id(v2))   #38544968 38544968二者内存地址一样

• 几个特殊情况

  在python中认为所有字符串，数字-5~256内存地址相同