python基础数据类型

已于 2022-03-01 09:28:41 修改
阅读量1.2k 收藏 2
点赞数 1
文章标签： python 开发语言
于 2022-01-20 14:50:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qianshuiliyu/article/details/122591053
版权

一、变量、常量、注释

1.1变量

  由字母、数字、下划线组成，不能以是数字开头，不能占用python关键字
  双下划线开头，双下划线结尾是python内置变量，尽量不适用双下划线开头结尾的
  变量与变量之间不互相指，变量指向数据
  变量在内存中是唯一命名的
  中文可以设置为变量，但是不要轻易使用

推荐命名方式：
  驼峰体：第一个单词的首字母大写
   大驼峰：MyName
   小驼峰：myname
   大小驼峰的不同在于开头的单词字母大小写不同
  下划线方式：
   my_name

1.2常量

一直不变的量叫做常量
python中没有真正的常量，为了迎合其它语言，约定俗成全部大写的变量称为常量
用来设置不变的数据，如id号、已经发生的事情等

1.3注释

单行注释：#
多行注释：三个单引号或者双引号抱起来

#单行注释
'''
单引号注释
'''
=====
"""
双引号注释
"""

二、基础

2.1格式化输出

第一种格式化

py='我的名字:%s,今年:%d,我的工作:%s,今年已经过了1%%' %('天一',18,'python')
#%是占位符，%s代表字符串，%d代表数字，显示百分之几加两个
print(py)#我的名字:天一,今年:18,我的工作:python,今年已经过了1%

第二种格式化输出format
format有三种用法：

1、按照位置一一对应
s1="我是{}，今年{}，性别{}".format('python大牛',18,'男')
print(s1)
#我是python大牛，今年18，性别男

2、按照索引对应
s1="我是{0}，今年{1}，性别{2}，你是{0}，今年{1}，性别{2}".format('python大牛',18,'男')
print(s1)
#我是python大牛，今年18，性别男，你是python大牛，今年18，性别男

3、使用变量名字对应
s1=("我是{name}，今年{age}，性别{sex}".format(name='python大牛',age=18,sex='男'))
print(s1)
#我是python大牛，今年18，性别男

2.2运算符

算术运算符+、-，比较运算符>==，赋值运算符=，逻辑运算符and、or，成员运算符，身份运算符

运算符符号
算术运算+，-，*，/，%（取余），//（取整），**（次方）
比较运算==（等于），！=（不等于），<>（不等于），>=（大于等于），<= （小于等于）
赋值运算=（等于），+=（自加，相当于count=count+1），-=，*=，…
逻辑运算and：和、or：或者 、not：取反

2.2.1算数运算

1、次方计算

#2的3次方
print(2**3)
#8

2、取余

print(10%3)
#1

3、取整

print(10//3)
#3

2.2.2赋值运算

先算等号右面的，然后再算等号左面的

count=0
count+=5#相当于count = cpunt+5，相当于0+5
print(print(count))#5

2.2.3比较运算

比较运算的结果是布尔：True （真）或者False（假）

print(5>6)
print(5<6)
print(5==6)
print(5!=6)
print(5>=6)
print(5<=6)
# False
# True
# False
# True
# False
# True

2.2.3逻辑运算

  逻辑运算优先级：在没有（）的情况下，优先级：not>and>or，同一优先级从左到右依次计算
  x or y , x为真，值就是x，x为假，值是y；
  x and y, x为真，值是y,x为假，值是x。

print(2>1 and 3<4 )
print(3<4 or 4>5 )
print(2>1 and 3<4 or 4>5 and 2<1)
print(True or False)
print(0 or 1)
print(1 or 0)
print(3 or 4)
print(4 or 3)

# True
# True
# True
# True
# 1
# 1
# 3
# 4

2.3类型转换

2.3.1 str-int

1、字符串转化整数：只能是纯数字组成的字符串

s1='0100'
n1=int(s1)
print(n1,type(n1))
#100 <class 'int'>

2、整数转化字符串

s1=100
n1=str(s1)
print(n1,type(n1))
#100 <class 'str'>

2.3.2bool-int

  所有的数据都可以转化成布尔值

1、整数转化布尔值：非零即True，0为False

n1=0
n2=100
n3=200
print(bool(n1))
print(bool(n2))
print(bool(n3))
# False
# True
# True

2、布尔值转化数字：只有1和0

n1=True
n2=False
print(int(n1))
print(int(n2))
# 1
# 0

3、字符串转化布尔值，非空位True，空格也是字符，布尔值转化字符串意义

n1=''#这里啥都没有
n2=' '#这里有个空格
print(bool(n1))
print(bool(n2))
# False
# True

2.3.2 str-boot

字符串转化布尔值，非空及true
只有变量值里面啥都没有（空格也不行）的时候才是False
布尔值加上引号就是字符串，基本没有意义

a='我是python大牛'
print(bool(a))
#True

```python
a=''
print(bool(a))
#False

三、基础数据类型

  数据类型就是计算机用来对数据的分类
  python中一共有八中数据类型

类型简介
number数字
string字符串
bool布尔
None空值
list列表
tuple字典
dict元祖
set集合

2.1 int整形

​python3中只有int一种数字类型
数字：1、2、3、4等等
取值范围：32位电脑上是-231~2 31-1，64位电脑是-263~263-1

num1=100
print(num1)
#100

2.1.1二进制转十进制

1、二进制00101010转十进制
计算方式：位上的数乘以2的x次方（x是第几位就是几）

#00101010转十进制
num1=0*2**0+1*2**1+0*2**2+1*2**3+0*2**4+1*2**5+0*2**6+0*2**7
print(num1)
#42

2.1.2统计有效的二进制位数：bit_lenth

#十进制转化成二进制的位数
num1=100
print(num1.bit_length())
#7

2.3str字符串

在python中，凡是用引号引起来的数据就称为字符串
有单引号，双引号，三引号（三对单引号或双引号）
存储少量数据，对其的任何操作获取的内容都是str类型，存储数据单一

s1='你好'
s2="你好"
s3='''你好'''
s4="""你好"""
s5="""你好
    世界
    """
#三个单引号或双引号赋值给变量就是字符串，否则就是注释

单双引号可以配合使用，因为有的地方可能是用英文单词缩写

s1="I'm python大牛"
s2='I'm python大牛'#单引号就会识别出错

2.3.1字符串之间拼接

s1="我是"
s2='python大牛'
s3=s1+s2
print(s3)#我是python大牛

2.3.2 str与int相乘

s1="我是"
s2=3
s3=s1*s2
print(s3)#我是我是我是

2.3.3索引

字符串从左到右是有顺序的，叫下标（索引）
从左到右第一个字符是索引0,第二个是1，依次类推
对字符串进行索引、切片出来的数据都是字符串类型

1、索引

1、按索引值取值，正取
s1="我是python大牛"
s2=s1[0]
print(s2)#我

2、按索引值取值，倒取，-1是最后一个，-2，-3依次往前
```python
s1="我是python大牛"
s2=s1[-1]
print(s2)#牛

2.3.4切片

切片：顾头不顾尾，根据索引取值（[0-3]，从0索引开始取，取不到3）
切片步长： [开始索引：结束索引：步长]
在开头取的话，0可以省略，默认从头开始，结束索引不写默认全部，步长默认是1，从左到右的顺序

1、顾头不顾尾

1、索引
s1="我是python大牛"
s2=s1[0:2]
print(s2)#我是

2、 在开头取的话，0可以省略

s1="我是python大牛"
s2=s1[:2]
print(s2)#我是

2、步长用法

s1="我是python大牛"
s2=s1[0:5:2]
#步长2就是隔一个取一个
print(s2)#我pt

3、倒着取

s1="我是python大牛"
s2=s1[-1::-1]
print(s2)#牛大nohtyp是我

2.3.5 upper-lower大小写转换

upper：英文字母全部变大写
lower：英文字母全部变小写
字符串的任何操作方法不会对原字符串进行任何操作，而都是产生一个新的字符

1、变大写
s1="我是python大牛"
s2=s1.upper()
print(s2)#我是PYTHON大牛

2、变小写
s1="我是python大牛"
s2=s1.lower()
print(s2)#我是python大牛

常见应用：输入验证吗的时候不区分大小写

code='qwer'
your_code=input('请输入验证码，不区分大小写：')
if your_code==code.lower() or your_code==code.upper():
    print("验证码输入正确")
else: print('验证码输入有误')

2.3.6startswith

判断一个字符串以什么开始，可以是一个或多个字符，返回的是布尔值

s1="我是python大牛"
s2=s1.startswith('我')
print(s2)#True

2.3.7endswith

判断一个字符串以什么结束，可以是一个或多个字符，返回的是布尔值

s1="我是python大牛"
s2=s1.endswith('大牛')
print(s2)#True

2.3.8replace

replace（旧内容，新内容，替换次数（不写默认全部替换，超出范围不报错，超出范围也是所有））
缺点：从前往后按顺序替换

在这里插入图片描述

s1="我是python大牛我是python大牛"
s2=s1.replace('我','你')
print(s2)
#你是python大牛你是python大牛

2.3.9 strip-len

空白去除，包括\n,\t,空格，tab等，也可以去除指定位置的字符，前后一起进行匹配，中间的无法消除
len：获取可迭代对象元素的总个数

1、去除空白
s1="   我是python大牛   "
print(len(s1))#16
s2=s1.strip()
print(s2,len(s2))#我是python大牛 10

2、去除指定的字符
s1="我是python大牛"
s2=s1.strip('我是大牛')
print(s2)#python

2.3.10split

分割，默认按照空格进程分割，返回一个列表，某些时候就是字符串转化列表
可以指定分隔符进行分割，以及分割次数

1、默认切割
s1="天一 天二 天三"
s2=s1.split()
print(s2)#['天一', '天二', '天三']

2、指定分割符
s1="天一:天二:天三"
s2=s1.split(':')
print(s2)#['天一', '天二', '天三']

3、根据索引指定分割次数
s1="天一:天二:天三"
s2=s1.split(':',1)
print(s2)#['天一', '天二:天三']

2.3.11 join

对可迭代对象进行连接，结果是字符串类型

1、单个字符串
s1="我是python大牛"
s2='-'.join(s1)
print(s2)
#我-是-p-y-t-h-o-n-大-牛

2、多个字符串
s1="天一",'天二','天三'
s2=':'.join(s1)
print(s2)#天一:天二:天三
#这种方法前提里面的元素必须都是字符串类型

3、列表中的字符串
s1=['天一','天二','天三']
s2=':'.join(s1)
print(s2)#天一:天二:天三
这种方法前提列表里面的元素必须都是字符串类型

2.3.12count

计算出现的次数

s1="我是python大牛我是python大牛"
s2=s1.count('python')
print(s2)#2

2.3.13 is

isalnum ：判断是不是由字母或数字组成
isalpha ：字符串只由字母组成
isdecimal：字符串只由十进制组成

1、判断是不是由字母或数字组成

s1=('python123')
s2=s1.isalnum()
print(s2)#True

2、字符串只由字母组成

s1=('python')
s2=s1.isalpha()
print(s2)#True

3、字符串只由十进制组成

s1=('123456789')
s2=s1.isdecimal()
print(s2)#True

2.3.14in/not in

in/notin：在/不在
1、in用法

s1="我是python大牛"
s2='python' in s1
print(s2)#True

2、not in用法

s1="我是python大牛"
s2='python' not in s1
print(s2)#False

2.3.15capitalize

capitalize，首字母大写，其余变小写

s1="pythON"
s2=s1.capitalize()
print(s2)#Python

2.3.16swapcase

swapcase，大小写翻转

s1="pythON"
s2=s1.swapcase()
print(s2)#PYTHon

2.3.17title

每个单词首字母大写（字母之间只要不连续，空格数字都算）
s1=“wo shi python daniu”
s2=s1.title()
print(s2)#Wo Shi Python Daniu

2.3.18center

center，居中
center（长度，填充（默认填充空白））

s1="wo shi python daniu"
s2=s1.center(50,'*')
print(s2)
#***************wo shi python daniu****************

2.3.19find

find，通过元素找索引，找到第一个就返回，找不到就返回-1

s1="我是python大牛"
s2=s1.find('大')
print(s2)#8

2.3.20index

index，通过元素找索引，找不到就报错

s1="我是python大牛"
s2=s1.index('我')
print(s2)#0

2.4 bool布尔

布尔只有两种结果：Ture，False
True为真，False为假

s1=1
s2=2
print(s1>s2)#False
print(s1<s2)#True

2.5 list列表

存放数据，元素可变
列表是有序的、可索引、切片（步长）的
python容器型数据类型，列表里面是什么类型，数据就是什么类型
可以对列表进行索引，切片，增删改查等，容器型的数据都可以

1列表操作

1、索引

l1=['我是python大牛',True,100,['我是python大牛',True,100]]
print(l1)
#['我是python大牛', True, 100, ['我是python大牛', True, 100]] <class 'list'>

l1=['我是python大牛',True,100,['我是python大牛',True,100]]
print(l1[0])
print(l1[-1])
#我是python大牛
#['我是python大牛', True, 100]

2、切片

l1=['我是python大牛',True,100,['我是python大牛',True,100]]
print(l1[0:2:])

3、复合索引
取嵌套中的数据

l1=['我是python大牛',True,100,['我是python大牛',True,100]]
print(l1[-1][-1])
#100

2列表创建

1、直接创建

l1=['我是python大牛',True,100,['我是python大牛',True,100]]

2、迭代创建

l1=[]
l1=list('我是python大牛')
print(l1)
#['我', '是', 'p', 'y', 't', 'h', 'o', 'n', '大', '牛']

3、列表推导式

l1=[i for i in range(1,10)]
print(l1)
#[1, 2, 3, 4, 5, 6, 7, 8, 9]

3列表的增

1、append：在末尾追加

l1=['我是python大牛',True,100,['我是python大牛',True,100]]
l1.append(100)
print(l1)
#['我是python大牛', True, 100, ['我是python大牛', True, 100], 100]

2、insert：插入数据
insert(索引位置，插入的数据)
不覆盖内容，在相应的位置上插入数据

l1=['我是python大牛',True,100,['我是python大牛',True,100]]
l1.insert(1,1000))
print(l1)
#['我是python大牛', 1000, True, 100, ['我是python大牛', True, 100]]

3、extend
迭代追加，最小元素追加

l1=['我是python大牛',True,100,['我是python大牛',True,100]]
l1.extend([100,200])
l1.extend('woshi')
print(l1)
#['我是python大牛', True, 100, ['我是python大牛', True, 100], 100, 200, 'w', 'o', 's', 'h', 'i']

4列表的删

1、pop按照索引删除

l1=['我是python大牛',True,100,['我是python大牛',True,100]]
l1.pop(0)
print(l1)
#[True, 100, ['我是python大牛', True, 100]]

2、remove，按照指定元素删除，如果有重名，删除从左数第一个

l1=['我是python大牛',True,100,['我是python大牛',True,100]]
l1.remove(100)
print(l1)
#['我是python大牛', True, ['我是python大牛', True, 100]]

3、del按照索引删除与切片删除

1、按照索引删除
l1=['我是python大牛',True,100,['我是python大牛',True,100]]
del l1[0]
print(l1)
#[True, 100, ['我是python大牛', True, 100]]

2、按照切片删除
l1=['我是python大牛',True,100,['我是python大牛',True,100]]
del l1[0:2]
print(l1)
#[100, ['我是python大牛', True, 100]]

4、clear，清空整个列表

l1=['我是python大牛',True,100,['我是python大牛',True,100]]
l1.clear()
print(l1)

5、循环删除（删除问题）

列表的索引是连续的，删除中间的元素，删除元素，索引不会删除，后面的往前补上，每删除一个元素，后面的索引和元素都会前进一位
循环删除按照索删除的话注意，删除的时候尽量倒着删除不影响
倒叙删除虽然元素和索引前进，但是我们是先删除在变化的，依次往前，所以变化不影响操作

删除索引数奇数所对应的元素
1、理论的删除

l1=[1,2,3,4,5,6]
for i in l1:
    print(i)
    if i%2==1:
        l1.pop(i)
print(l1)#[1, 3, 4, 6]

在这里插入图片描述
2、真正的删除

方法一：直接删除
l1=[1,2,3,4,5,6]
del l1[1::2]
print(l1)#[1, 3, 5]
方法二：倒叙删除
l1=[1,2,3,4,5,6]
for i in range(len(l1)-1,0,-1):
    print(i)
    if i%2==1:
        l1.pop(i)
print(l1)#[1, 3, 5]
方法三：置换
l1=[1,2,3,4,5,6]
l2=[]
for i in range(len(l1)):
    print(i)
    if i%2==1:
        l2.append(l1[i])
l1=l2
print(l1)

5列表的改

1、按照索引修改

l1=['我是python大牛',True,100,['我是python大牛',True,100]]
l1[0]='pytohn'
print(l1)
#['pytohn', True, 100, ['我是python大牛', True, 100]]

2、按照步长修改

l1=['我是python大牛',True,100,['我是python大牛',True,100]]
l1[0:2]='1234'
print(l1)
#['1', '2', '3', '4', 100, ['我是python大牛', True, 100]]

6列表的查

1索引

l1=['我是python大牛',True,100,['我是python大牛',True,100]]
l2=l1[0]
print(l2)#['我是python大牛', True, 100]
l2=l1[-1]
print(l2)#我是python大牛

2、切片

l1=['我是python大牛',True,100,['我是python大牛',True,100]]
l2=l1[0::2]
print(l2)#['我是python大牛', 100]

7列表嵌套

修改嵌套列表中的内容

l1=['我是python大牛',True,100,['我是python大牛',True,100]]
l1[-1][1]=100
print(l1)#['我是python大牛', True, 100, ['我是python大牛', 100, 100]]

在这里插入图片描述

8其他操作

1、count统计列表的某个元素出现的次数

l1=['我是python大牛',True,100,['我是python大牛',True,100]]
l2=l1.count(100)
print(l2)

2、index从列表中找出某个值第一个匹配项的索引位置

l1=['我是python大牛',True,100,['我是python大牛',True,100]]
l2=l1.index(100)
print(l2)#2

3、sort，对原列表进行排序，默认从小到大
reverse，将列表中的元素反向存放

l1=[1,2,3,4,5]
l1.sort()#默认从小到大
print(l1)#[1, 2, 3, 4, 5]
l1.sort(reverse=True)#从大到小，reverse（方法将列表中的元素反向存放）
print(l1)#[5, 4, 3, 2, 1]

4、列表相加

l1=[1,2,3,4,5]
l2=[6,7,8,9,10]
l3=l1+l2
print(l3)#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

5、列表与整数相乘

l1=[1,2,3,4,5]
l2=l1*3
print(l2)#[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

9列表拆包

列表的拆包，分别赋值，必须一一对应，多了少了都不行

l1,l2=['我是python大牛',True]
print(l1)#我是python大牛
print(l2)#True

10 range

range：数字范围的列表，里边必须是数字
语法：range（开始数字，结束数字，步长）
range经常与for循环结合获取索引

l1=range(10)
print(l1)#range(0, 10)，里面的数字是从0-9，顾头不顾尾
for i in l1:
    print(i)

1、索引

l1=range(10)
print(l1[1])

2、切片

l1=range(10)
for i in range(1,10,2):
    print(i)

3、获取索引

l1=['我是python大牛',True,100]
for i in range(len(l1)):
    print(i)

2.6 tuple元祖

元祖只能查，不能增删改，可以对里面的列表进行元素的修改，可以索引、切片（步长），但是列表不能删除
存放数据，元素不可变，存放重要信息

1元组的查

1、索引查看

l1=('我是python大牛',True,100,['我是python大牛',True,100,])
l2=l1[0]
print(l2)#我是python大牛

2、切片查看

l1=('我是python大牛',True,100,['我是python大牛',True,100,])
l2=l1[0:3]
print(l2)

3、获取元素个数

l1=('我是python大牛',True,100,['我是python大牛',True,100,])
l2=len(l1)
print(l2)

4、修改元组中列表的内容

将列表中的True修改为False
l1=('我是python大牛',True,100,['我是python大牛',True,100,])
l2=l1[-1][1]=False
print(l1)#('我是python大牛', True, 100, ['我是python大牛', False, 100])

2元组拆包

元组的拆包，分别赋值，必须一一对应，多了少了都不行

l1,l2=('我是python大牛',True)
print(l1)
print(l2)

3元组特性

python中元组有一个特性，元组中如果只含有一个元素且没有逗号，则该元组不是元组，与改元素数据类型一致，如果有逗号，那么它是元组

l1=('我是python大牛')
print(l1,type(l1))#我是python大牛 <class 'str'>
l1=('我是python大牛',)
print(l1,type(l1))#('我是python大牛', ) <class 'tuple'>

2.7 dict字典

数据类型的分类：（可变与不可变）
可变（不可哈希）的数据类型：list，dict，set
不可变（可哈希）的数据类型：str，bool，int，tuple

字典存放关联型数据，查询速度快 ，元素可变，容器型数据类型
列表的查询速度很慢，关联性不强
字典：{‘readme’:{‘name’:‘python大牛’}}，以键值对存储的容器型数据类型，冒号前面是键，后面是值，放在一起是一组键值对
字典的键类似索引，可以通过键对字典进行取值
键必须是不可变的数据类型：str， int，tuple bool，值可以是任意数据类型对象，唯一，不唯一取最后面的
优点：查询速度非常快，存储关联性的数据，导致以空间换时间
有时增就是改改就是增

1字典的创建方式

1、直接创建
dic={'name':'python大牛'}
print(dic)#{'name': 'python大牛'}
2、内置函数dict，里面放元组，元组里面放小元组
dic=dict((('name','python大牛'),('age',18)))
print(dic)#{'name': 'python大牛', 'age': 18}
3、内置函数dict
dic=dict(name='python大牛',age=18)
print(dic)#{'name': 'python大牛', 'age': 18}
4、内置函数dict
dic=dict({'name':'python大牛','age':18})
print(dic)#{'name': 'python大牛', 'age': 18}
5、内置函数dict+zip
dic=dict(zip(['naem','age'],['我是python大牛',18]))
print(dic)#{'name': 'python大牛', 'age': 18}
6、dict
dic={k : v for k,v in [('naem','python大牛'),('age',18)]}
print(dic)#{'name': 'python大牛', 'age': 18}
7、dict
fromkeys：字典的所有键来自一个可迭代对象，字典的值使用同一个值
dic=dict.fromkeys('name','python大牛')
print(dic)#{'n': 'python大牛', 'a': 'python大牛', 'm': 'python大牛', 'e': 'python大牛'}
8等等

2字典的增

1、增加键，如果键存在，则是修改，不存在则是增加

dic={'name':'python大牛','age':'18','sex':'男'}
dic['爱好']='女'
print(dic)#{'name': 'python大牛', 'age': '18', 'sex': '男', '爱好': '女'}

2、setdefault，有则不变，无则增加

dic={'name':'python大牛','age':'18','sex':'男'}
dic.setdefault('爱好','女')
dic.setdefault('name','python')
print(dic)#{'name': 'python大牛', 'age': '18', 'sex': '男', '爱好': '女'}

3、update增

dic={'name':'python大牛','age':'18','sex':'男'}
dic.update(爱好='玩')
print(dic)#{'name': 'python大牛', 'age': '18', 'sex': '男', '爱好': '玩'}

3字典的删

pop，按照键删除键值对，有返回值，可以设置第二个参数，无论字典中有无此键，都不会报错，存在这个键，就返回删除的内容，否则就是你设置的参数内容

1、pop删除

dic={'name':'python大牛','age':'18','sex':'男'}
dic.pop('name')
print(dic)#{'age': '18', 'sex': '男'}
=====
dic={'name':'python大牛','age':'18','sex':'男'}
l1=dic.pop('naxdf','不存在')
print(l1)#不存在
print(dic)#{'name': 'python大牛', 'age': '18', 'sex': '男'}

2、clear清空

dic={'name':'python大牛','age':'18','sex':'男'}
dic.clear()
print(dic)#{}

3、del，按照键去删除，不存在就报错

dic={'name':'python大牛','age':'18','sex':'男'}
del dic['name']
print(dic)#{'age': '18', 'sex': '男'}
del dic['name']
print(dic)#KeyError: 'name'

4字典的改

1、直接给键赋值

dic={'name':'python大牛','age':'18','sex':'男'}
dic['name']='python'
print(dic)#{'name': 'python', 'age': '18', 'sex': '男'}

2、update

1改
dic={'name':'python大牛','age':'18','sex':'男'}
dic.update(name='python',age=20)
print(dic)#{'name': 'python', 'age': 20, 'sex': '男'}

2、增
dic={'name':'python大牛','age':'18','sex':'男'}
dic.update(爱好='玩')
print(dic)#{'name': 'python大牛', 'age': '18', 'sex': '男', '爱好': '玩'}
3、增改
dic={'name':'python大牛','age':'18','sex':'男'}
dic.update([('爱好','玩'),('身高',180)])
print(dic)#{'name': 'python大牛', 'age': '18', 'sex': '男', '爱好': '玩', '身高': 180}
4、增
dic1={'name':'python大牛','age':'18','sex':'男'}
dic2={'name':'python','age':20}
dic1.update(dic2)
print(dic1)#{'name': 'python', 'age': 20, 'sex': '男'}
print(dic2)#{'name': 'python', 'age': 20}

5字典的查

1、根据键去查询，不存在就报错

dic={'name':'python大牛','age':'18','sex':'男'}
l1=dic['name']
print(l1)#python大牛

2、get，可以设置返回值，有此键返回键的值，没有返回设置的值，默认是none

dic={'name':'python大牛','age':'18','sex':'男'}
l1=dic.get('name','不存在')
print(l1)#python大牛
l1=dic.get('100','不存在')
print(l1)#不存在

3、keys()，获取所有的键

dic={'name':'python大牛','age':'18','sex':'男'}
l1=dic.keys()
print(l1)#dict_keys(['name', 'age', 'sex'])

4、values()，获取所有的值

dic={'name':'python大牛','age':'18','sex':'男'}
l1=dic.values()
print(l1)#dict_values(['python大牛', '18', '男'])

5、items()，以列表里面包含元组显示键和值

dic={'name':'python大牛','age':'18','sex':'男'}
l1=dic.items()
print(l1)#dict_items([('name', 'python大牛'), ('age', '18'), ('sex', '男')])

6、字典的拆包

dic={'name':'python大牛','age':'18','sex':'男'}
for key,values in dic.items():
    print(key,values)
'''
name python大牛
age 18
sex 男
'''

6字典的嵌套

将age=18，修改为age=20

dic={'个人信息':{'name':'我是python大牛','age':18}}
dic['个人信息']['age']=20
print(dic)#{'个人信息': {'name': '我是python大牛', 'age': 20}}

7循环字典

1、循环字典

dic={'name':'python大牛','age':'18','sex':'男'}
for i in dic:
    print(i)
'''
name
age
sex'''

2、循环一个字典时，如果改变一个字典的大小（增加或删除），就会报错

dic={'name':'python大牛','age':'18','sex':'男'}
for i in dic:#RuntimeError: dictionary changed size during iteration
    dic['爱好']='python'
    print(i)
print(dic)

3、在循环的时候怎样去做呢

dic={'name':'python大牛','age':'18','sex':'男'}
l1=[]
for i in dic:
    if i == 'name':
        l1.append(dic)

for i in l1:
    dic['爱好']='python'
print(dic)#{'name': 'python大牛', 'age': '18', 'sex': '男', '爱好': 'python'}

2.8 set集合

set集合，容器型数据类型，她要求里面的元素是不可变的，但是它本身是可变的数据类型；集合是无序的，{}里面放元素就是集合，放键值对就是字典
作用：列表去重；关系测试（交集、并集、差集…）

1创建

set1={'我是python大牛',True,100,100}
print(set1,type(set1))#{'我是python大牛', True, 100} <class 'set'>

2空集合

dic={}#空字典
s=set()#空集合
print(dic,type(dic))#{} <class 'dict'>
print(s,type(s))#set() <class 'set'>

3集合的增

1、add，直接增加

set1={'我是python大牛',True,100,}
set1.add(1000)
print(set1)#{1000, True, '我是python大牛', 100}

2、update（）迭代更新并去重

set1={'我是python大牛',True,100,}
set1.update('pythonpython')
print(set1)#{True, 'n', 100, 't', 'h', 'o', '我是python大牛', 'y', 'p'}

4集合的删

1、remove（）按照元素删除

set1={'我是python大牛',True,100,}
set1.remove(100)
print(set1)#{'我是python大牛', True}

2、pop（随机删除）

set1={'我是python大牛',True,100,}
set1.pop()
print(set1)#{'我是python大牛', 100}

5集合的改

集合不能直接改，只能变相改，先删除了，在增加

set1={'我是python大牛',True,100,}
set1.remove(100)
set1.add(200)
print(set1)#{'我是python大牛', True

6其他

1、交集（&或者intersection）
两个都有的元素就是交集

set1={'我是python大牛',True,100,200,300}
set2={'我是python大牛',True,100,200}
print(set1 & set2)#{200, True, 100, '我是python大牛'}

2、并集（|或者union）
数据集合到一起就是并集

set1={'我是python大牛',True,100,200,300}
set2={'我是python大牛',True,100,200}
print(set1 | set2)#{True, 100, 200, 300, '我是python大牛'}

3、差集（-或者difference）
我有你没有的，我差你就是我有你没有

set1={'我是python大牛',True,100,200,300}
set2={'我是python大牛',True,100,200}
print(set1 - set2)#{300}

4、反交集（^或者symmetric_difference）
除了交集所有的

set1={'我是python大牛',True,100,200,300}
set2={'我是python大牛',True,100,200}
print(set1 ^ set2)#{300}

5、子集与超集
子集：我包含你，你就属于我，你就是我的子集
超集：我包含你，我就是你的超集

7去重

l1=[1,2,3,1,2,3]
l2=set(l1)
print(l2)#{1, 2, 3}

2.9数据类型分类

容器类型：列表、元祖、字典
可变：列表、字典
不可变：数字，字符串，元组，布尔值
直接访问：数字
顺序访问：字符串、列表、元祖
key值访问：字典

按存储空间划分：（从低到高）
数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：有序，需要存key与value映射的相关信息，可变，需要处理数据的增删改（3.6之后有序）

四、其他基础

1、id

id：唯一标识
开辟的数据占用空间，空间在内存中有有对应的内存地址
使用id可以获取内存地址，到的的数字是随机的；内存是临时加载数据，运行完就消失了
id唯一，相同就是一样的
python的id是虚拟的，目的是让你查看是不是同一个
id相同，值一定相同，值相同，id不一定相同

dic={'name':'python大牛','age':'18','sex':'男'}
print(id(dic))#1955228316672
l1=100
l2=200
print(id(l1))#2273801164240
print(id(l2))#2273801167504

2、is

1判断内存地址是否相等

l1=100
l2=200
print(l1 is l2)#False

l1=100
l2=100
print(l1 is l2)#True

==

判断两边的数据是否相等，返回Ture或者False

s='我是python大牛'
g='我是python大牛'
print(g==s)#True

3代码块

python程序由代码块构成，一个模块，一个函数，一个类，一个文件等都是一个代码块
交互方式输入的每一个命令都是一个代码块

同一代码块的机制

两个机制：同一个代码块下，有一个机制，不同的代码块下，遵循另一个机制

  • 同一个代码块下的缓存机制，也叫字符串驻留机制

前提：同一个代码块内
python在执行同一个代码块的初始化对象的命令时，会检查是否其值是否已经存在，如果存在，会将其重用。换句话说：执行同一个代码块时，遇到初始化对象的命令时，他会将初始化的这个变量与值存储在一个字典中，在遇到新的变量时，会先在字典中查询记录，如果有同样的记录那么它会重复使用这个字典中的之前的这个值。所以在你给出的例子中，文件执行时（同一个代码块）会把l1,l2两个变量指向同一个对象，满足缓存机制则他们在内存中只存在一个，即：id相同。

目的：节省内存，提升性能
适用对象：int（float）、bool、srt
具体规则：所有的数字，bool，几乎所有的字符串
在这里插入图片描述

不同代码块的机制

  • 不同代码块下的缓存机制：小数据池

不在统一代码块
在内存中提前开辟好了一定范围数字或一定规则的字符串
适用对象：int（float）、bool、srt
具体规则：-5-256数字，bool，满足规则字符串
优点：提升性能，节省内存

浅水鲤鱼
关注
Python数据类型详解
悦分享
04-28 308
因此，我们习惯这样计数：0，1，2，3，4，5，6，7，8，9。接着是11，12，一直到19，然后仿照之前的做法，我们将新多出来的1加到十位来组成20（2个十加0个一），以此类推。类似地，可变对象就像一个开着口的盒子，你不仅可以看到里面的数据，还可以拿出来修改它，但你无法改变这个盒子本身，即你无法改变对象的类型。你可能会经常遇到这种子序列，例如"Strontium，90，Carbon，14"或者"Vikings，20，Packers，7"，等等，每个子序列的第一个元素作为键，第二个元素作为值。
Python基础-数据类型总结归纳.
weixin_30835923的博客
07-25 449
1.1、python3　数据类型： 类型含义示例 int 整型 1 float 浮点型 1.0 bool 布尔值 True或False complex 复数 a+bj string 字符串 ‘abc123’ list 列表 [a,b,c] tuple 元组 (a,b,c) se...
【python基础】基本数据类型
最新发布
hiliang521的博客
07-18 1319
【python基础】基本数据类型
python 尖括号表示什么类型,Python的小括弧，中括号，大括号还有尖括号的区别...
weixin_36400833的博客
03-25 3193
在使用python做项目的过程中发现这种语言使用了很多种类型的括号来表达数据类型，常见的有四种，分别是：小括号( )、中括号[ ]和大括号，也叫做花括号{ }，还有尖括号<>，其作用也各不相同，分别用来代表不同的python基本内置数据类型。1、python中的小括号( )：代表tuple元组数据类型，元组是一种不可变序列。创建方法很简单，大多时候都是用小括号括起来的。>>...
Python基础（变量、数据类型、输入与输出、格式化输出、算术运算）
llllyr的博客
08-29 944
文章目录1. Python简介2. Python2与Python3的区别4.Python中的变量5.Python的输入与输出6. Python格式化输出7.Python中的算术运算 1. Python简介 Python意为蟒蛇，创始人是吉多.范罗苏姆；Python语言是以C为基础的，用C语言来实现，并能够调用C语言的库文件，可扩展性较强。 计算机在执行程序时，需要编译器来将其他语言翻译成计算机可...
Python基础数据类型、变量、常量
bafengji2881的博客
09-12 184
1.变量：把程序运行的中间结果临时的存在内存中，以便后续的代码调用 变量不仅可以是数组，还可以是任意数据类型。在程序中，变量就是用一个变量名表示，变量名必须是大小写英文、数字、和‘_’下划线组合，并且不能以数字开头。比如： name = 'Jack' 上面代码声明一个变量，变量名：name，值为：‘Jack’。变量name是一个字符串 Answer = True ...
Python基础数据类型
09-13
入门级基础知识，本人学习整理笔记，对小白很友好，有兴趣的学习的朋友可以查阅。
Python基础案例教程教案-基本数据类型.doc
06-12
在这个"Python基础案例教程教案-基本数据类型"中，我们关注的是Python中的基本数据类型，尤其是整数和浮点数，以及如何进行数值计算和输出。 首先，整数是不包含小数部分的数值，如1033、-1020。浮点数则带有小数...
python基础数据类型实验体会_《Python基础学习心得》2.3.1
weixin_39767645的博客
12-19 1490
2.3.数据类型应用一、序列(一).序列对象作为以非负整数为索引的有限有序集合，其共性操作有以下几种：1. len ( )函数【练习】尝试在Python平台上输入下列代码，回车运行后，观看屏显结果：>>> print ( len ( 'changdu' ) )7>>>屏幕返回的数据是数字 7，由此可验证该字符串(单引号对包含的数据)的长度是 7。len ( ) ...
0-5 Python 基础数据类型-字节、列表-附件资源
03-05
0-5 Python 基础数据类型-字节、列表-附件资源
【Python基础篇】Python中的七种数据类型
热门推荐
qq_44723773的博客
01-14 2万+
a = b[begin, end, step]，begin表示开始位置，默认为0，end表示结束位置，默认为变量长度，step表示步长，默认为1。从存储的角度来理解，浅拷贝就是增加了指针指向值的存储地址，并没有对值开辟新的内存空间进行存储，深拷贝则是开辟新的内存空间去存储并指针指向新的内存地址。如果从相对简单的角度来理解的话，浅拷贝和深拷贝是针对嵌套对象的区别，对原数据的嵌套对象的修改，浅拷贝对应的嵌套对象会同步影响，深拷贝就不会受影响。列表是以[]定义，用英文逗号分隔开的集合，元素是可以重复的。
Python 中的几种常用数据类型
很酷的站长的博客
12-30 2535
本文简略介绍 Python 中每种数据类型的定义和使用场景，使得学习者获得对 Python 的数据类型的整体认识，在后续的小节中详细介绍每种类型的具体使用细节。
【Python数据类型浅析】
W_chuanqi的博客
04-01 3580
映射类型是“键-值”数据项的组合，每个元素是一个键值对，即元素是(key, value)，元素之间是无序的。=）的结果是逻辑型数据。上述操作符表达了集合类型的4种基本操作，交集（&）、并 集（|）、差集（-）、补集（^），操作逻辑与数学定义相同。如果S与T相同或S是T的子集，返回True，否则返回False，可以用ST判断S是否是T的真超集。返回一个新集合，包括集合S和T中元素，但不包括同时在其中的元素。
《Python语言程序设计》王恺 机械工业出版社 第五章课后习题答案
qq_51527538的博客
10-25 7905
第五章 序列、集合和字典 5.8 课后习题 （1）Python 中，通过列表中的 index 方法可以根据指定值查找第一个匹配的列表元素 的位置。 （2）Python 中，通过列表中的 insert 方法可以将一个元素插入到列表的指定位置。 （3）若在列表的最后添加新元素，则可以直接使用列表的 append 方法。 （4）使用 del 语句可以删除某个变量或列表中的某个元素。 （5）使用 max 方法可以获取一个列表中最大元素的值。 （6）使用 min 方法可以获取一个列表中最小元素的值。
Python全栈（一）基础之14.面向对象（3）
CUFEECR的博客
11-16 1712
面向对象是Python的重要思想之一，本篇博客从多态说起，到方法的重写，super()的使用，再到多重继承的分析，再谈到面向对象的另一个重要特性——多态，最后分析了实例方法、实例属性、类方法、类属性，用了大量的实例和对比分析，加深对语法和概念的理解，适合初学者。
python判断元素是什么类型
Harland的博客
03-11 7924
项目中可能会以某个元素的类型作为判断条件，以下是简单两种判断方式 type 会返回files的类型 用法：type（object） >>> files = ["001.txt","002.conf","003.sh"] >>> type(files) <type 'list'> 2.isinstance是Python中的一个内建函数 用法：is...
python六大数据类型详解
Jarrodche的博客
10-13 1万+
史上最全数据类型详解，详细介绍了Python3 中六个标准的数据类型：Number（数值）、String（字符串）、List（列表）、Tuple（元组）、Set（集合）、Dictionary（字典）。六大数据类型的方法和常规操作。
Python中的数组格式函数
左左张
01-24 4060
Python中的数组格式 2019/1/24 import numpy as np len() #返回对象的第一维长度 a = [1,2,3] len(a) #output:3 len([a,a]) #output:2 len(np.array(a)) #output:3 shape() #返回ndarray对象每维度的大小 #numpy模块的函...
Python基础数据类型操作详解与转换
本文提供的内容涵盖了Python中这些数据类型的基本操作，对于初学者来说，理解和掌握这些基础操作至关重要，因为它们构成了构建复杂程序的基础。熟练运用这些知识能有效提高编程效率，减少错误。如果遇到问题或有任何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

浅水鲤鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值