python数据类型内置方法以及深浅拷贝

目录

• 数字类型内置方法
  • 整型 int
  • 浮点型 float
• 字符串内置方法
  • 优先掌握
    • 1.索引
    • 2.索引切片
    • 3.for循环
    • 4.成员运算
    • 5.strip()#默认去除两端空格，可以指定去除的字符，可以指定多个字符同时去掉
    • 6.split()#切割
    • 7.len长度
  • 需要掌握
    • lstrip&rstrip
    • lower&upper
    • startswith&endswith
    • rsplit
    • join
    • replace
    • isdigit/isalpha
  • 了解
    • find|rfind|index|rindex|count
    • center|ljust|rjust|zfill
    • expandtabs
    • captalize|swapcase|title
    • is系列 ：有兴趣看下
• 列表内置方法
  • 优先掌握
    • 1.索引取值/索引修改值
    • 2.切片
    • 3.for循环
    • 4.成员运算
    • 5.len
    • 6.append()
    • 7.del 删除
  • 需要掌握
    • insert
    • pop:按照索引删除值
    • remove:按照值删除值
    • count:计数
    • index:寻找值的索引
    • clear:清空列表
    • copy:拷贝列表
    • extend：扩展列表
    • reverse:反转列表
    • sort:排序
• 元组的内置方法
  • 什么是元组（了解）
  • 作用
  • 定义方式
  • 使用方法
  • 有序or无序
  • 可变or不可变
• 字典内置方法
  • 作用
  • 定义方式
  • 使用方法
    • 优先掌握
    • 需要掌握
  • 有序or无序
  • 可变or不可变
• 散列表（哈希表）
• 集合内置方法
  • 作用
  • 定义方式
  • 使用方法
  • 有序or无序
  • 可变or不可变
• 数据类型总结
  • 存值个数
  • 有序or无序
  • 可变or不可变
• 深浅拷贝
  • 拷贝
  • 浅拷贝
  • 深拷贝

数字类型内置方法

整型 int

1.作用：年龄/id

2.定义方式：

x=10

3.使用方法：+ - * / % // ** < <= > >= == !=

4.有序or无序（有索引的就有序，无索引的无序）：压根就没有有序无序一说

5.可变or不可变（值变id不变叫可变，值变Id变叫不可变）：整型不可变

浮点型 float

1.作用：薪资

2.定义方式：

x=10.1

3.使用方法：+ - * / % // ** < <= > >= == !=

4..有序or无序：压根就没有有序无序一说

5.可变or不可变：不可变

字符串内置方法

1.作用：姓名

2.定义方式：单引号/双引号/三单引号/三双引号

4.有序or无序：有序

5.可变or不可变：不可变

3.使用方法：

优先掌握

1.索引

2.索引切片

s='nick handsome'
print(s[0:4])#顾头不顾尾
print(s[0:4:2])#2表示步长，隔一个取一个
print(s[4:0:-1])#+是从左到右，-是从右到左

3.for循环

for i in s:
    print(i)

4.成员运算

print('nick' in s)
print('nick1' not in s)#true

5.strip()#默认去除两端空格，可以指定去除的字符，可以指定多个字符同时去掉

s1='a nick    *****'
print(s1.strip())
print(s1.strip(' *'))#可以乱序，但是不能没有

6.split()#切割

s2='nick|123456|180|140'
print(s2.split('|'))#按照|切割字符串，得到的是一个列表

7.len长度

s='nick handsome'
print(len(s))

需要掌握

lstrip&rstrip

s='**nick**'
print(s.lstrip('*'))
print(s.rstrip('*'))

lower&upper

s='Nick'
print(s.lower())#小写
print(s.upper())#大写

startswith&endswith

s='nick handsome'
print(s.stsrtswith('nick'))#以。。。开始
print(s,endswith('some'))#以。。。结束

rsplit

s2='nick|123456|180|140'
print(s2.split('|'))#从右开始 按照|切割字符串，得到的是一个列表

join

s='nick|123456|180|140'
lt=s.split('|')
print('*'.join(lt))#使用*拼接列表内的每一个元素

replace

s='hand handsome'
s=s.replace('nick',nick chen)#替换

isdigit/isalpha

s='45613'
print(s.isdigit())#判断字符串内字符是否都为数字

了解

find|rfind|index|rindex|count

s='nick handsome'
print(s,find('h'))#找索引，-1表示没找到
print(s.rfind('h',6,10))

print(s.index('fds'))#找不到就报错

s='aaacc'
print(s.count('a'))

center|ljust|rjust|zfill

s='nick'
print(s.center(50,'*'))#居中
print(s.ljust(50,'*'))#居左
print(s.rjust(50,'*'))#居右
s='111'
print(s.zfill(8))

expandtabs

s='a\t\t\ta'
print(s)
print(s.expandabs(18))

captalize|swapcase|title

s= 'nickNick handsome'
print(s.captalize())#首字母大写
print(s.swapcase())#大小写互转
print(s.title())#每个单词的首字母大写

is系列 ：有兴趣看下

列表内置方法

1.作用：存储多个值

2.定义方式：[]用逗号隔开多个元素

4.有序or无序：有序

5.可变or不可变：可变

3.使用方法

优先掌握

1.索引取值/索引修改值

lt=[1,2,3,4]
print(lt[1])
lt[1]=3
print(lt)

2.切片

print(lt[:])
print(lt[1:2])
print(lt[1:4:2])

3.for循环

for i in lt:
    print(i)

4.成员运算

print(i in lt)

5.len

print(len(lt))

6.append()

lt.append(5)
print(lt)

7.del 删除

del lt[0]
print(lt)

需要掌握

insert

lt=[1,2,3,4,5]
lt.insert(0,0)#往前插入
print(lt)

pop:按照索引删除值

lt.pop(0)
print(lt)

remove:按照值删除值

lt.remove(1)
print(lt)

count:计数

lt=[11,11,11,33]
print(lt.count(11))

index:寻找值的索引

print(lt.index(11))

clear:清空列表

lt=[1,2,3,4]
lt.clear()
print(lt)

copy:拷贝列表

lt1=lt.copy()

extend：扩展列表

lt1=[1,2,3]
lt2=[2,3,4]
lt1.extend(lt2)

reverse:反转列表

lt.reverse()

sort:排序

lt.sort()

元组的内置方法

什么是元组（了解）

只可取，不可更改的列表

作用

元组一创建就被写死了

定义方式

（）内用逗号隔开隔开多个元素（可以为任意数据类型）

如果元组只有一个元素，必须得加逗号

tup=(1,2,3)
tup=(3,)

使用方法

1.索引取值

print(tup[0])

2.索引切片

print(tup[0:3])

3.for循环

for i in tup:
    print(i)

4.成员运算

print(0 in tup)

5.len长度

print(len(tup))

6.index获取元素索引

print(tup,index(1))

7.count计数

print(tup,count(2))

有序or无序

有序

可变or不可变

压根不存在这一说法

字典内置方法

作用

存储多个数据，对每个数据具有描述

定义方式

{}内用逗号隔开多个键key（具有描述意义，不能为可变数据类型）：值value（任意数据类型）对

dic={'name':1}
dic={0:'功能1',1:'功能2'}

使用方法

优先掌握

1.按key取值/按key修改值

dic={'a':1,'b':2,'c':3}
print(dic['a'])
dic['b']=4

2.添加值，没有就添加，有就修改

dic['d']=4
print(dic)

3.for循环

for i in dic:
    print(i)

4.成员运算

print('a' in dic)

5.len长度

print(len(dic))

6.keys/values/items

print(dic.key())#看成列表
print(dic.values())#获取所有值
print(dic.items())
for i in dic.items():
    print(i)
for k,v in dic.items():
    print(k,v)

需要掌握

get:获取

dic={'a':1,'b':2,'c':3}
print(dic[s])# 报错
print(dic.get('b'))# 没有就返回None
print(dic.get('b'，1))# 没有就返回None，可以给定一个默认值

update:更新，等同于list里的extend

dic1={'a'=1,'c'=2}
dic2={'b'=1,'d'=2}
dic1.update(dic2)

fromkeys

print(dict.fromkeys([1,2,3,4]))#{1: None, 2: None, 3: None, 4: None}

setdefault :字典有这个key，就不修改，没有则增加

dic.setdefault('j',2)
dic.setdefault('a',2)

有序or无序

无序

可变or不可变

可变

散列表（哈希表）

1.首先对key做了哈希处理（能对所有数据类型都可以哈希处理）：梅森旋转算法（生成伪随机数）--》通过哈希处理对于每个key他都可以生成一个序列（永不重复，相同的东西进入哈希处理，结果相同）

2.使用哈希函数对刚刚生成的序列（纯数字），对纯数字除9取余（0，1，2，3，4，5，6，7，8）

集合内置方法

什么是集合：交集/并集/补集/差集

作用

1.进行上述运算

2.去重

3.乱序--》基于散列表实现的

定义方式

{}内以逗号隔开多个元素（不可变元素）

s={}#空字典
s=()#空集合

使用方法

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
# 并集
print(pythoners | linuxers)
# 交集
print(pythoners & linuxers)
# 差集
print(pythoners - linuxers)
# 补集
print(pythoners ^ linuxers)
# add（*******）
pythoners.add('oscar')
print(pythoners)

pythoners,remove('oscarl')#没有报错
print(pythoners)
pythoners.discard('oscarl')#没有不报错
print(pythoners)
pythoners.pop()  # 随机删除一个
print(pythoners)

有序or无序

无序

可变or不可变

可变

数据类型总结

存值个数

存一个值：整型/浮点型/字符串

存多个值：列表/元组/字典/集合

有序or无序

有序：字符串/列表/元组

无序：字典/集合

可变or不可变

可变：列表/字典/集合

不可变：整型/浮点型/字符串/元组

深浅拷贝

拷贝

当lt2为lt1的拷贝对象时，无论lt1内部为可变类型还是不可变类型，lt1内部元素变化，lt2也变化

浅拷贝

当lt2为lt1的拷贝对象时，lt1内部的不可变元素变化，lt2不变。lt1内部的可变元素变化时，lt2也随之变化

深拷贝

当lt2为lt1的拷贝对象时，无论lt1内部的可变元素或不可变元素怎么变化，lt2都不会变化。