Python精简入门学习(五)

Python精简入门学习之高级数据类型
-序列:

在python当中 序列就是一组按照顺序排列的值[数据集合]。
在python中 存在三种内置的序列类型。
字符串、列表、元组。
优点:
    可以支持索引和切片的操作。
特征:
    第一个正索引为0 指向的是左端 第一个索引为负数的时候 指向的是右端。

-切片:

[高级特性] 可以根据下标来获取序列对象的任意[部分]数据。
语法结构:[start:end:step] step默认为1
常用的代码:
    1.capitalize()  首字母变大写
    2.endswith/startswith()  是否x结束/开始
    3.find()  检测x是否在字符串中
    4.isalnum()  判断是否是字母和数字
    5.isalpha()  判断是否是字母
    6.isdigit()  判断是否是数字
    7.islower()  判断是否是小写
    8.join()  循环取出所有值用xx去连接
    9.lower/upper  大小写转换
    10.swapcase  大写变小写 小写变大写
    11.lstrip/rstrip/strip  移除左边/右边/两边的空格
    12.split()  切割字符串
    13.title()  把每个单词的首字母变成大写
    14.replace(old,new,count=None)  old被换字符串 new替换字符串 count换多少个 无count表示全部替换
    15.count()  统计出现的次数

-字符串操作

T = 'China'
print('获取第一个字符:%s'%T[0])
print('获取第一个字符:{}'.format(T[1]))
for i in T:
    print(i,end=' ')
    pass

name = 'rose'
print('姓名首字母转换成大写:%s'%name.capitalize())

a = '     strip()移除空格     '
b=a.strip()     # 移除两边空格
print(b)
print(a.lstrip()) # 移除左边空格
print(a.rstrip()) # 移除右边空格
print('a的内存地址为%d'%id(a))
b = a       # 只是把a对象的内存地址赋值给了b
print('b的内存地址为%d'%id(b))
print(b)

dataStr = 'I Love China'
print(dataStr.find('M'))    # 可以查找目标对象在序列对象中的值 如果没有找到返回-1
print(dataStr.index('o'))   # 检测字符串中是否包含子字符串 返回的是下标值 如果没有找到对象的数据 就会报异常 而find()不会
print(dataStr.startswith('I'))  # 判断是否以' '开头
print(dataStr.endswith('n'))    # 判断是否以' '结尾

print(dataStr.lower())      # 转换成小写
print(dataStr.upper())      # 转换成大写

strMsg = 'hello world'
# [start:end:step]  左闭右开 start<= value < end 范围
print(strMsg) # 输出完整的数据
print(strMsg[0])
print(strMsg[2:5])  # 2-5下标之间的数据
print(strMsg[2:])   # 第三个字符到最后
print(strMsg[:3])   # 1-3  strMsg[0:3] = strMsg[:3]
print(strMsg[::-1]) # 倒叙输出 负号表示方向 从右往左

# 共有方法 + * in
# 字符串合并
strA = '人生苦短'
strB = '我用python'
print(strA+strB)
# list 合并
listA = list(range(10))
listB = list(range(11,20))
print(listA+listB)
# 复制 *
print(strA*3)
print(listA*3)
# in 对象是否存在 结果是bool值
print('生' in strA)
print(9 in listA)
dictA = {'name':'peter'}
print('name' in dictA)

-list:

 python当中非常重要的数据结构 是一种有序的数据集合。
特点:
    1.支持增删改查。
    2.列表中的数据是可以变化的[数据项可以变化 内存地址不会改变]。
    3.用[]来表示列表类型 数据项之间用逗号来分割 注意 数据项可以是任何类型的数据。
    4.支持索引和切片来进行操作。
常用代码:
    1.append  在列表后面追加元素
    2.count  统计元素出现的次数
    3.extend  扩展 相当于批量添加
    4.index  获取指定元素索引号
    5.insert  在指定的位置插入
    6.pop  删除最后一个元素
    7.remove  移除左边找到的第一个元素
    8.reverse  反转列表
    9.sort  列表排序  reverse = True 倒叙

-list操作

li = [] #空列表
li = [1,2,3,'你好',6,7,8]
print(len(li)) # len() 获取列表对象中的数据个数
strA = '我喜欢python'
print(len(strA))
print(type(li))
# 查找
listA = ['java',678,12.34,'python',True,'C#']
print(listA)        # 输出完整的列表
print(listA[0])     # 输出第一个元素
print(listA[1:3])   # 输出第二个开始到第三个元素
print(listA[2:])    # 输出第三个到最后所有的元素
print(listA[::-1])  # 负数从右边往左开始输出
print(listA*3)      # 复制

# 增加
print('追加前',listA)
listA.append(["key",'fly'])  # 追加操作
listA.append(123)
print('追加后',listA)
listA.insert(1,'这是刚插入的数据')  # 插入操作 需要执行一个位置插入
print(listA)
rsData = list(range(10))    # 强制转换为list对象
print(type(rsData))
listA.extend(rsData)    # 拓展等于批量添加
listA.extend([1,2,3,4])
print(listA)

# 修改
print('修改之前',listA)
listA[0] = 30
print('修改之后',listA)
print()
listB = list(range(10,50))

# 删除
print(listB)
del listB[0]        # 删除列表中第一个元素
del listB[1:3]      # 批量删除多项数据 slice
listB.remove(20)    # 删除指定的元素
listB.pop(1)        # 移除指定的项 参数是索引值
print(listB)
print(listB.index(19,20,25)) # 返回的是一个索引下标 查找19 从下标20开始查到25 长度为5 因为19不在里面所以报错

-tuple:

是一种不可变的序列 在创建之后不能做任何的修改。
特性:
    1.不可变。
    2.用()创建元组类型 数据项用逗号来分割。
    3.可以是任何的类型。
    4.当元组中只有一个元素时 要加上逗号 不然解释器会当作整形来处理。
    5.同样可以支持切片操作。

-元组操作

# 元组的创建 不能进行修改
tupleA = () # 空元组
print(id(tupleA))
tupleA = ('ace',81,3.14,'tony',[1,2,3])
print(id(tupleA))
# print(type(tupleA))
# print(tupleA)
# 元组的查询
for item in tupleA:     # for循环遍历
    print(item,end=' ')
print()
print(tupleA[2:4])       # 表示下标2到下标4的取值
print(tupleA[::-1])      # 倒叙输出
print(tupleA[::-2])      # 表示反转字符串 每隔两个取值
print(tupleA[::-3])      # 表示反转字符串 每隔三个取值
print(tupleA[-2:-1:])    # 倒着取下标 为-2 到 -1 区间的值
print(tupleA[-4:-2:])    # 倒着取下标 为-4 到 -2 区间的值

tupleA[4][0] = 666          # 可以对元组中的列表类型的数据进行修改
print(type(tupleA[4]))      # 查看数据类型
print(tupleA)

tupleB = ('1',) # 当元组中只有一个数据项的时候 必须在第一个数据项后面加上逗号
print(type(tupleB))
tupleC =(1,2,3,4,3,4,4,1)       
print(tuple.count(4))           # 可以统计元素出现的次数

-dict:

是python中重要的数据类型 字典是有 键值对 组成的集合 通常使用键来访问数据 效率非常高 和list一样 支持对数据的添加、修改、删除。
特点:
    1.不是序列类型 没有下标的概念 是一个无序的 键值集合 是内置的高级数据类型。
    2.用{}来表示字典对象 每个键值对用逗号分隔。
    3.键 必须是不可变的类型[元组、字符串] 值可以是任意的类型。
    4.每个键必定是唯一的 如果存在重复的键 后者会覆盖前者。

-字典操作

# 创建字典
# dictA = {}   创建空字典
dictA = {'pro':'艺术','school':'赛亚人学校'}
# 添加字典数据
dictA['name'] = '张三'   # key:value
dictA['age'] = '18'
dictA['pos'] = '讲师'
# 结束添加
print(dictA)        # 打印输出
print(len(dictA))   # 数据项长度
print(type(dictA))  # 数据类型

print(dictA['name'])    # 通过键获取对应的值
dictA['name'] = '张学友' # 修改键对应的值
dictA['school'] = '北京邮电大学'
dictA.update({'height':'1.80'}) # 可以添加或者更新
print(dictA)

# 获取所有的键
print(dictA.keys())

# 获取所有的值
print(dictA.values())

# 获取所有的键和值
print(dictA.items())

for item in dictA:  # 循环遍历
    print(item)

for key,value in dictA.items():     # 循环遍历
    print('%s=%s'%(key,value))


# 删除操作
del dictA['name']   # 通过指定键进行删除
dictA.pop('age')    # 通过指定键进行删除
print(dictA)

# 排序    按照key
print(sorted(dictA.items(),key=lambda d:d[0]))
# 按照value
print(sorted(dictA.items(),key=lambda d:d[1]))