Python数据类型和其方法

String字符串、list列表、深浅拷贝、tuple元组、dict字典、set集合。

---

补码--->数据

把这个补码看作一个原码继续求其补码就是原码

String字符串：

什么是字符串？

字符串是以单引号或双引号括起来的任意文本。

引号本身是一种表现形式，不属于字符串

注意：如果字符串本身带双引号，里面用单引号 外侧用双引号

里面用双引号 外侧用单引号。

创建字符串：

str1=”hello world ”

str2=”hello_world”

字符串运算

字符串拼接：+

print(str1+str2)

字符串重复：*

print(str1*3)

通过索引下标获取字符串中的字符，索引从0开始

print(str1[1])

截取字符串中一部分 切片编程

print(str1[11,15])

判断字符串中是否存在某些内容：

print(‘’hello”  in  str1)

格式化输出：

%s 格式化字符串

%d     格式化整数

%f 格式化浮点数，可以指定小数点后的精度，默认保留小数点后六位。

如果只有一个替换，可以不写%后的小括号，但是建议不省略。

%nd ：左边空n个

%-nd：右边空n个

%.nd：左边空n个补0

常用的转义字符：

反斜杠 \\ 想打印出来 \

单引号 \’

双引号  \”

换行   \n

如果字符串内部有多个换行，写在一行里不利于阅读 这个时候用三引号””””””

横向制表符 \t

如果字符串里卖弄有很多字符需要转义，就需要加入很多\，为了方便允许在前面加入r使这个字符串内所有的字符都不进行转义

 

字符串内的函数：

eval()

原型：eval(*args,**kwargs)

功能：将字符串当成有效的表达式来求值，并返回计算结果

参数：字符串 或者是变量 其中可以有运算符号 将对运算

len(string)

功能：返回字符串的长度(按字符的个数计算)

参数：字符串

lower()

功能：转换字符串中所有的大写字母为小写，无法改变其原来字符串。

upper()

功能：转换字符串中所有的小写字母，转为大写字母

swapcase()

功能：将字符串中字母大写转为小写，小写转为大写

capitalize()

功能：将字符串中第一个字符转为大写

tittle()

功能：将字符串中每个空格隔开的字符开头转为大写

center(width[ , fillchar])

功能：返回一个指定宽度width的居中字符 fillchar为0填充字符，默认是空格

ljust(width[ , fillchar])

功能：返回一个指定宽度width的左对齐的字符串，fillchar为填充字符，默认是空格

rjust(width[ , fillchar])

功能：返回一个指定宽度width的右对齐的字符串，fillchar为填充字符，默认是空格

zfill(width)

功能：返回一个指定宽度width的右对齐的字符串，填充字符默认为0，默认是空格

count(str,beg=0,end=len(string))

功能：返回str在string里面出现的次数。如果beg或者end指定则返回指定范围内的str出现的次数

find(str,beg=0,end=len(string))

功能：检查str是否包含在String中，如果只当beg和end，则检查指定范围内是否包含，如果包含，则返回第一个开始的索引值，否则返回-1

index(str,beg=0,end=len(string))

功能：功能和find一样。如果不存在，会报异常

rfind()

功能：从右侧开始查找

rindex()

功能：从右侧开始查找

lstrip()

功能：截掉字符串左边的字符，默认为空格

rstrip()

功能：截掉字符串右边的字符，默认为空格

strip()

功能：截掉字符串两边的字符，默认为空格

split(str=””[, num=string.count(str)])

功能：以str 将字符串分割为列表

splitlines([keepends])

功能：按照行(‘\r’,’\r\n’,’\n’)，如果keepends 为Flase，不包含换行符，默认为True

join(seq)

功能：将列表进行拼接。

max(str)

功能：返回字符串中最大的字母 按照ascii码值

min(str)

功能：返回字符串中最小的字母 按照ascii码值

replace(old, new[, max])

功能：将字符串中的old子串换成new，如果max指定那么替换不超过max次

maketrans()

功能：创建字符映射的转换表，对于接受两个参数的，第一个是字符串，表    示要转换的字符，第二个也是字符串，表示转化的目标。是一一对应的，这个是创建一个table表，在后边直接可以调用这个表。字典形式的存的是ascii  前后的字符串长度需要相等。

translate(table)

功能：根据str给出的表转换字符串，需要提前告诉转换表

isalpha()

功能：如果字符串至少有一个字符串并且所有的字符都是字母，返回True否则返回Flase

isalnum()

功能：如果字符串至少有一个字符串并且所有的字符都是字母或数字，返回True否则返回Flase

isupper()

功能：如果字符串至少有一个字符串并且所有的字母都是大写字母，返回True否则返回Flase

islower()

功能：如果字符串至少有一个字符串并且所有的字母都是小写字母，返回True否则返回Flase

istitle()

功能：如果字符串是标题话的返回True，否则返回False

idfigit()

功能：如果字符串只包含数字返回True,否则返回Flase

isnumeric()

功能：如果字符串只包含数字返回True,否则返回Flase

isdecimal()

功能：检查字符串是否只包含十进制数字，是就返回True否则返回Flase

isspace()

功能：如果字符串中只包含空格返回True，否则返回Flase（\t \n 也算空格）

startswith(str, begin=0, end=len(string))

功能：检查字符串是否以str开头，是就返回True,否则返回Flase，如果指定了beg和end，就在指定范围内检查。

endswith(suffix, begin=0, end=len(string))

功能：检查字符串是否以suffix结尾，是就返回True,否则返回Flase，如果指定了beg和end，就在指定范围内检查。

encode(encoding=’UTF-8’,errors=’strict’)

功能：以encoding指定的编码格式进行编码，如果出错就报一个ValueError异常，除非eerrors只当的是 ignore 或者replace

byte,decode(encoding=”utf-8”,errors=’strict’)

功能：以encoding指定的编码格式进行解码，如果出错就报一个ValueError异常，除非eerrors只当的是 ignore 或者replace

str()

功能：转为字符串的形式。ASCII码值

ord()

功能：获取字符的整数表示，单个字符，字符串不可以。ASCII码值

chr()

功能：把数字编码转为对应的字符ASCII码值

布尔值：

一个布尔值只有True、Flase两种，要么是True要么是Flase

作用：作为真假的判断。

空值： 是python中一个特殊的值，用None表示，None不能理解为0，因为0是由意义的，None是一个特殊的空值，没有实际的意义。

作用，定义一个变量时，不知道要赋值成什么，那么就赋值围殴None，当由确定值再进行赋值操作。

变量的类型问题。

变量的类型要根据对应的数据类型判断具体是什么类型，变量的类型是变化的。

"""
list 列表
问题 ：定义五个人年龄 最后求出他们的平均年龄
"""
age1=10
age2=18
age3=50
age4=5
age5=30
print((age1+age2+age3+age4+age5)/5)
"""
如果存储1000个年龄求他们的平均年龄：
解决：使用列表
列表本质： 是一种有序的集合
创建列表
格式： 列表名 = [列表选项1, 列表选项2, ..., 列表选项n]
"""
#创建空列表
list1 = []
#创建有元素的列表
#列表中的元素的数据类型可以不同
list2 = [1,2,3,45,4,5,4,"good",True]
"""
列表元素的访问
1.取值：       列表名[下标]
2.替换修改     列表名[下标] = 数值
"""
print(list2[2])
list2[2] = 1000
print(list2)
#注意 下标不要超过列表的界限
#列表的操作
list3 = [1,2,3]
list4 = [4,5,6]
print(list3+list4) #得到的是一个新的列表
#列表重复
print(list4*3)#也是得到一个列表
#in         not in
print(1 in list3)
print(1 not in list3)
#列表截取（切片）
list5 = [1,2,3,4,5,6,7,8,9,4,5,6,2]
print(list5[2:7])
print(list5[2:-1])#-1表示的是最后一个元素的下标。
#二维列表： 列表元素是一维列表 本质：本质就是一维列表 在内存里储存就是列表
"""列表中的方法"""
#append(object)     在列表的末尾加入一个元素
list=[1,2,3,4,5,5,9,7,1,2,3,5]
list.append(6)
#只能在末尾添加一个元素。
# extend(seq)       在列表末尾一次追加多个元素
list.extend([9,8,7,])
#insert（index,obj）         将元素插入列表
list.insert(2,100)
#将元素右移，不会覆盖
#pop(obj=list[-1])      默认删除的是-1
list.pop()#可以写进去下标。
#remove(obj)        移除列表中的某个值的第一个匹配项
list.remove(8)
print(list)
#clear() 清空列表
list.clear()
print(list)
#index()      找出列表中匹配项第一个下标
list6 = [1,2,1,2,3,4,5,6,2,3]
print(list6.index(2))
#len(list)    返回列表中元素的个数
#count（）        统计某个元素在列表中出现的次数
print(list6.count(2))
#max()  min()       返回列表中元素的最大值，最小值
#reverse()      倒叙列表中的元素
print((list6.reverse())) #可以改变内容
#sort([func])       排序 默认升序排列
print(list6.sort())
#list(seq)      转为列表   字符串，元组，集合 等。
from  copy import copy,deepcopy
#copy       拷贝
浅拷贝和深拷贝
深浅拷贝的区分在于列表中是否有其他对象列表'''
"""
==:判断的是值
is：判断的是内存地址
"""
a = [1,2,1,[1,2,1]]
b = a
print(a == b)
print(id(a),id(b))
print(a is b)
#浅拷贝：只拷贝表层元素
#copy
b = copy(a)
#深拷贝：在内存中重新创建所有子元素
#deepcopy
c = deepcopy(a)
print(a == b)
print(c == a)
print(a is b)
print(a is c)
print(id(a), id(b), id(c))
print(id(a[3]), id(b[3]), id(c[3]))
"""
tuple 元组
"""
#本质：也是一种有序集合，
#特性：1.与列表非常类似 2.一旦初始化就不能修改 3.使用小括号。
#创建元组： 元组名 = （元组选项1，元组选项2，...，元组选项n）
t1 = ()
#定义带元素的元组 语速类型可以不同
t2 = (1,2,3,"good",True)
print(t2)
#定义含有一个元素的元组的时候要注意加个,
t3 = (1,)
print(t3)
#元组元素的访问
#取值  元组名[下标],不能超过下标，可以使用负数
t4 = (1,2,3,4,5)
print(t4[2])
print(t4[-2])
#修改元组， 我们不能修改其中的元素 但是能修改元素内的列表
t5 = (1,2,3,[1,2,3])
t5[3][1] = 100    #根据下标修改
print(t5)
#元组的操作 和列表的操作基本相同
#元组的组合
#元组的重复
#元组截取（切片）
#元组的方法
#len(tuple) 返回元组的元素个数
#index 查找拿到下标  count
#max(tuple)
#min(tuple)
#tuple(seq)     转为元组
"""
字典：
使用键—值对（key — value）的形式存储数据，具有极快的查找速度
特性：
    1.字典的key必须唯一
    2.key必须是不可变对象 字符串、整数、元组等都是不可变的对象
    但是 列表是可变的，不能作为key
    3.key 一般为字符串
思考 ：保存一个学生的基本信息（姓名，性别，年龄，身高，体重。）
解决： 使用字典
"""
#创建字典 存储一个学生的基本信息
#格式 {key1：value1，key2：value2}
stu={"name":"sunck", "age":18, "sex":"男",
     "height": 173.5, "weight": 75}
#元素的访问
#获取     字典名[key]    字典.get[key]
print(stu["name"])#获取的键不存在会报错
print(stu.get("score"))#一般都是用get来获取
#添加
stu["score"] = 89.90
stu["height"] = 180#如果键不存在则增加属性否则覆盖原数据。
#删除
stu.pop("score")#删除指定的项
print(stu)
#遍历
for key in stu:#拿到的是键
    print(stu[key])
for value in stu.values():#拿到的是值
    print(value)
for key, value in stu.items():#拿到的是键和值
    print(key,value)
#字典的是无序的
for index,key in enumerate(stu):#拿到的是元组
    print(index, key)
"""
比较 list 和dict
dict：
    优点：查找和插入的速度极快，而且不会随着key的增多而降低效率
    缺点：需要占用大量的内存，内存浪费过多
list:
    优点：占有内存小，浪费内粗你少
    缺点：查找和插入的时间会随着元素的增加而增加
"""
"""
set:集合
与dict类似，是一组Key的集合（不存储value）
本质：无序和无重复的集合
"""
#创建:需要用一个list或者tuple作为输入集合
#注意：列表中的重复元素会被过滤掉
s1 = set([1,2,3,4,5])
print(s1)
#应用：列表去重
numlist = [1,2,3,4,5,6,7,8,9,7,8,5,6,5,1,2,0,3,1,2]
#numlist = list(set(numlist))
print(numlist)
#添加
#插入list、字符串、元组的每个元素
s2 = set([1,2,3,4,5])
s2.update([7,8,9])
s2.update("hello_world")
s2.update((6,7,8))
#不能直接插入数字
s2.update(range(9))
print(s2)
#删除
s3 = set([1,2,3,4,5])
print(s3.pop())#从左侧开始删除
s3.remove(3)#删除指定元素，如果元素不存在会报KEyError的异常
print(s3)
#遍历
s4 = set([6,5,2,3,1])
for key in s4:
    print(key)#遍历是按照顺序的
for index, key in enumerate(s4):
    print(index,key)#索引没有意义。
#交集和并集
s5 = set([1,2,3,4])
s6 = set([3,4,5,6])
#交集
print(s5 & s6)
#并集
print(s5 | s6)
"""
list 、 tuple 、string-> set #list和tuple中的元素不能存在可变对象
set()
tuple 、 set 、string-> list
list()
list  、 set 、string-> tuple
tuple()
"""