python--基本数据类型
一，变量
1，什么是变量之声明变量
变量名=变量值
name= ‘egon’ age = 18 sex = ‘female‘ 等
2，为什么要有变量
变量作用：变==》变化， 量===》衡量，计量/保存状态
程序运行本质是一系状态变化，变化的目的就是用来保存状态，变量值的变化就构成了程序运行的不同结果。
3，变量值之类型与对象
程序中需要处理的状态很多，有了不同类型的变量值，x = ‘egon’，变量值‘egon’的存放于内存中，绑定一个名字x，变量及我们要存储的数据
4，可变对象与不可变对象
可变对象：本身可以被其他方法或手段改变的
不可变对象：本身不可以被改变的
5，容器对象：包含其他对象的引用，称为容器或集合
6，对象的属性和方法
对象属性就是对象值，方法----能够调用这些方法能够使原来的对象发生变化
7，变量的赋值操作
1，链式赋值：y = x = a =1
2，多元赋值：x，y=1,2，x，y=y，x
3，增量赋值：x+=1
python 中的数据类型
python使用对象模型来存储数据，每一个数据类型都有一个内置方法，每新建一个数据，就是初始化一个对象，即及所有数据都是对象
对象的三个特性 id----地址 类型-------type 值------value
注意：当我们定义 name = ‘金星’ 时，内部就会生成这一内存对象（触发）
标准数据类型
*****在python中所有数据都是围绕对象这个概念来构建的，对象包含一些基本的数据类型，数字，字符串，列表，字典，元组，集合等。
二，数字类型
定义：a = 1
特性：1，只能存放一个值 2，一经定义不可更改 3，直接访问
分类：整型(int)，长整型(long)，布尔(bool)，浮点(folat)，复数(complex)
****python2与python3的不同
***注：在python3中没有长整形long，如果字符串过长，python3会自动默认为长整形
在python2中有：整形（int）和长整形long
int：整形，数字运算（python中的整数可以用十进制，八进制，十六进制表示）
>>> 10
10 --------->默认十进制
>>> oct(10)
'012' --------->八进制表示整数时，数值前面要加上一个前缀“0”
>>> hex(10)
'0xa' --------->十六进制表示整数时，数字前面要加上前缀0X或0x
三，bool（布尔）类型
布尔值就两种：True，False。就是反应条件的正确与否。
真 1 True。
假 0 False。
四， 字符串 （Str = ‘abc’，用单引号或双引号引起来的数据就是字符串）
定义：是一个有序的字符集合，用于存储少量或单个数据。是不可变类型，按照从左至有的顺序定义字符集合，下标是从零开始。有序
*****字符串常用操作：
移除空白，分隔，长度，索引，切片
索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。
a = 'ABCDEFGHIJK'
print(a[0])
print(a[3])
print(a[5])
print(a[7])
切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）。
a = 'ABCDEFGHIJK'
print(a[0:3])
print(a[2:5])
print(a[0:]) #默认到最后
print(a[0:-1]) #-1就是最后一个
print(a[0:5:2]) #加步长 print(a[5:0:-2]) #反向加步长
print(a[:]) 什么都不写，方括号中只写：，就可以复制一个原来的字符串或列表等
字符串常用内置方法：
# 1，find通过元素找索引，可切片，找不到返回-1 # 2，index，求索引，找不到报错。 # 3，split 由字符串分割成列表，默认按空格。 # 4，captalize 首字母大写，其他字母小写。 # 5，upper 全大写。 # 6，lower 全小写。 # 7，title，每个单词的首字母大写。 # 8，startswith 判断以什么为开头，可以切片，整体概念。 # 9，endswith 判断以什么为结尾，可以切片，整体概念。 # 10，format：格式化 # {}{}{}.format(有顺序) # {0}{1}{2}{0}.format（有顺序的） # '{name} {age}'.format(name=李复，age=12) # 11, strip 默认去掉两侧空格，有条件， # 12，lstrip 除去左边空格 # 13, rstrip 除去右边空格 # 14, center 居中，默认空格。 # 15，count查找元素的个数，可以切片，若没有返回0 # 16，expandtabs 方法把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是 8。 # 17，tabsize -- 指定转换字符串中的 tab 符号('\t')转为空格的字符数。 # a = '\t\t\tegon\t\t\t' # a.expandtabs(tabsize=8) # egon # print(a) # 18，replace（old，new,次数） 替换 # 19，isdigit，判断是否为数字组成 返回bool值 # 20，isalpha, 判断是否为字母组成 返回bool值 # 21，isalnum 判断是否为字符和字母组成 返回bool值 # 12,swapcase 大小写翻转 # 23，for i in 可迭代对象。 # 24，join：字符串拼接 # 25，len()：求字符串，列表，数字长度
五，列表list（ret = [1,2,3,'abc',[1,2],(1,2,3)]）-------可变类型（有序）
定义：变量的值放在【】里面，[ ]内以逗号分隔，按照索引，存放各种类型，每个位置代表一个元素
特性：1，可存放多个值 2，可修改指定索引为值对应的值 3，按照从左至右的顺序定义列表元素，下标从0开始。
2，创建列表
list_test = ['1hf'，12，‘ok’] 或 list_test = list('abc') 或 list_test = list(['lhf'，12，‘ok’])
3，列表常用操作
索引--------切片------追加-------删除------长度-------循环--------包含
增： append----追加 insert-------按索引增加 extend-------迭代添加
#；列表的增 # 1.insert--按索引增加， # li = [1,'a','b',2,3,'a'] # li.insert(1,'金鑫') # li.insert(3,'马德胜') # print(li) # 2.append---追加，没有返回值 # li = [1,'a','b',2,3,'a'] # li.append('太白金星') #增加到列表最后面 # li.append([1,3,5]) #append中只能跟一个类型，数字，字符串，列表，字典等 # print(li) # 3.extend--迭代添加,将被添加的类型中的每一个元素或字符一个一个添加，没有返回值，默认跟到最后面 li = [1,'a','b',2,3,'a'] # li.extend('ABC') # li.extend(['太白金星','金鑫']) # li.extend({'k':'v','k1':'k2'}) # li.extend('w,r,c') # print(li)
删：pop------按索引删，有返回值 remove-----按元素删，没有返回值 clear----清空列表，返回空列表 del----按索引和切片删，可以删除整个列表，没有返回值
# 1.pop # li = [1,'a',['a',10],{'k1':'v1'}] # # a = li.pop() #pop如果不指定索引删除，默认删除最后一个元素 # a = li.pop(-1) #指定索引删除 # print(li,a) # 2.remove # li = [1,'a',['a',10],{'k1':'v1'}] # # li.remove(1) #按元素删 # # li.remove() #后不跟指定元素报错 # print(li) # 3.del # li = [1,'a',['a',10],{'k1':'v1'}] # del li[2] #按索引删 # del li[0:2] #按切片删，顾头不顾尾 # del li #删除整个列表，不能输出，没有返回值 # print(li) # # 4.clear # li = [1,'a',['a',10],{'k1':'v1'}] # li.clear() #请空列表， # print(li)
改：按索引或切片修改(按切片修改是迭代式修改)
# li[2] = '马德胜' #按索引改 # li[2] = ['gsdfg',1,2] #按切片修改 # li[0:2] = '台标金鑫' #迭代修改 li[0:2] = ['太白','金鑫'] #迭代修改 print(li)
查：按索引，切片，循环查找
#查-----按切片，索引，循环查找 li = [1,'a',['a',10],{'k1':'v1'}] # 1,print(li[2]) #索引查 # 2.print(li[0:3]) #切片查找时，顾头不顾尾 # 3.for i in li: #循环查找 # print(i)
其他操作：
1，count：计数，统计一个元素在列表中出现的次数
li = [1,2,3,2,8,2] #或字符串 a = li.count(2) #有返回值 print(a)
2，index：找某个元素在列表中位置的索引
li = ['a','b','c','d','e'] # a = li.index('b') # b的在列表中位置的索引为1 b = li.index('e') # e为4 # print(a) print(b)
3，sort：对列表元素进行顺序排序，没有返回值.sort（revers ）
# li = [1,2,3,2,8,2,4,9,10,6,7,5] # li.sort() #[1, 2, 2, 2, 3, 4, 5, 6, 7, 8, 9, 10] 顺序排序 # li.sort(reverse=False) #正序排序 # li.sort(reverse=True) # 倒序排序 # print(li) # li = ['a','f','b','e','c','d'] # li.sort() # print(li)
4，reverse：将列表中的元素反向存放（翻转）
# i = [1,2,3,2,8,2,4,9,10,6,7,5] # i.reverse() #翻转（前后调换顺序）,可以与sort配合连用 # print(i) #[5, 7, 6, 10, 9, 4, 2, 8, 2, 3, 2, 1] # li = ['a','b','c','d'] # li.reverse() # print(li)
***重点：当循环列表时，如果在循环中删除某个或者某些元素，列表元素个数改变，索引改变，容易出错。
六，元组（tupe）---不可变类型，可存放任意类型的数据
1，定义：与列表类似，只不过【】改为（）
2，特性：可存放多个值
3，不可变类型
4，按照从左至右的顺序定义元组，下标从0开始顺序访问，有序
元祖创建：
ages = （11，12，33，45）或 ages = tuple（（11,12，13,58））
元组常用操作：
索引-------切片--------循环------长度------包含
元组也是一种列表，也可以用切片，只不过取出来的值还是元组形式
l = (1,2,3,4,5,6) print(l[0::2])
七，字典 ---可变类型（字典的key是不可变类型），无须，数据关联性强，python中唯一的映射类型，以键值对（key--value）的形式存储数据。字典的键必须是可哈希的。
字典时出列表意外python中最灵活的内置数据类型，列表是有序的对象结合，字典时无须的对象结合。
字典与列表之间的区别在于，当字典中的元素是通过键来存取的，而不是通过便宜存取的。
****注意：python中，不可变类型（数字，字符串，元组，）都是可哈希的，**字典的键也是可哈希的**而字典，列表本身则不是可哈希的，因为它们是可变类型。
6-1：增（两种方式）
# 1方式一 dic1 = {'name':'德胜','age':'18','sex':'男'} # dic1['name'] = '金星' # print(dic1) #当字典为空时，添加键值对，当字典中的键值存在时，键不变，值覆盖，当字典中的键值不存在时，则添加键值对。 # 2方式二 # setdefault :在字典中添加键值对，如果只有键那对应的值用None代替，若原字典中存在设置的键值对，不会被更改和覆盖 # dic1.setdefault('k','v') # print(dic1) # dic1.setdefault('k','v1') dic1.setdefault('k') #键对应的值默认为None print(dic1)
6-2：删
#字典的删除有四种方式 # 1pop根据键删除值（根据key删value）,有返回值，如果要删除的key不存在，报错 dic1 = {'name':'德胜','age':'18','sex':'男'} # a = dic1.pop('name') #按键删除值 # dic1.pop('德胜') #按值不能删除键（报错） # dic1.pop('gdsfgs') #间不存在，则报错 # print(a,dic1) #方式二 # del 无返回值 # del dic1['name'] #根据键删除值 # del dic1 #不能直接删掉整个字典 # del dic1['gfhfghsdf'] #若键不存在时，删除则报错， # print(dic1) # 方式三 # popitem #随机删除字典的某个键值对，将删除的键值对以元组的形式返回 # dic1.popitem() # print(dic1) #方式四 # clear 清空字典，返回一个空字典 dic1.clear() print(dic1)
6-3 改
# 字典的改有两种方式 #方式一 dic1 = {'name':'德胜','age':'18','sex':'男'} # dic1['name'] = '英雄' #根据键改值 # print(dic1) #方式二 # update：用于两个字典合并，原字典中有的键值对，键不变，值覆盖。没有的键值对添加到原字典中 dic2 = {'name':'爱根','hobbie':'篮球'} dic1.update(dic2) #没有的添加，相同的覆盖 print(dic1)
6-4 查
# 字典的查有两种方式 dic1 = {'name':'德胜','age':'18','sex':'男'} # 方式一 # value= dic1['name'] #按键查值 # print(value) # value1 = dic1['dfsdds'] #没有就会报错 # print(value1) # 方式二 # value = dic1.get('name') #根据键找对应的值 # print(value) value1 = dic1.get('fdgdfg') #若要查的值不存在，不报错，默认返回None print(value1)
6-5 字典的其他操作
#字典其他操作 dic1 = {'name':'德胜','age':'18','sex':'男'} # # 1---items # item = dic1.items() #这个类型就是dict_items类型，可迭代的 # print(item) #dict_items([('name', '德胜'), ('age', '18'), ('sex', '男')]) # 2---keys #或取所有的键 # key = dic1.keys() # print(key) #dict_keys类型 # 3---values 3获取所有的值 valur = dic1.values() print(valur) # dict_values类型
6-6 字典的循环
dic1 = {'name':'德胜','age':'18','sex':'男'}
# 1，
# for key in dic1: #获取所有的键（key）
# print(key)
# for key in dic1.keys(): #获取所有的key
# print(key)
# 2，
# for value in dic1.values(): #获取所有的值（value）
# print(value)
# 3，
# for item in dic1.items(): #以元组的形式获取元素
# print(item)
# 4，
# for key,value in dic1.items(): #获取元组
# print(key,value)
for ------循环
for 循环：用户按顺序循环可迭代对象的内容 # msg = '老男孩python是全国范围内最好的python培训机构' # for item in msg: #循环遍历字符串的每一个元素 # print(item) # li = ['alex','银角','女神','爱根','太白'] # for i in li: #遍历列表的每一个元素 # print(i) # dic = {'name':'太白','age':18,'sex':'man'} # for k,y in dic.items(): # print(k,y)
enumerate----枚举
# enumerate----枚举 （同时可以获得索引和值） li = ['alex','银角','女神','爱根','太白'] # for i in enumerate(li): 索引默认从0开始 # print(i) # for index,name in enumerate(li,1): #可以设置索引起始值 # print(index,name) for index,name in enumerate(li,100): print(index,name)
range：指定范围，生成指定数字
#range :指定范围，生成指定数字 # for i in range(1,10): #取1-10之间的数 # print(i) # for i in range(1,10,2): #取1-10之间的数（有步长） # print(i) for i in range(10,1,-2): #反向步长 print(i)
1.可变量类型与不可变类型----------- 可变的水类型：指的是在ID不变的情况下，数据类型内部元素value可变
注意：在python基本数据类型中：可变类型有：字典（dict’）和列表（list），不可变类型有：数字（int/float），字符串（str），元组（tuple）和集合（set）
定义一个数字类型 num=10
定义一个类型的三个特征： id 、 type（类型） ， value （从变量名获取）
-------列表---可变类型---可存多个值，主看元素，每一个元素都可以改都可以存
--------字典---不能出现重复的key，key跟一个值唯一映射
---------不可变的数据类型：value改变，id也跟着改变
如：数字---------整体存整体改
浮点型：
字符串-----修改也是开辟了新的内存空间--------不可变类型------整体存整体改
-----布尔---True对应1 false对应0
-----------运算符（+加、-减、*乘、/除）-------------算数运算符
//：地板除---------取整 %-----取余/取模 **-------次方
字符串------可以用+与*
列表--------用+ ，*（只能加乘）
以上两种类型都可以拼接。。。。。。
字典--------不能+，-，*，/
比较运算符------数字
num1=3 num2=1
>,<,>=,<=,==,!=
==判断的是值
is判断的是id
字符串比较----字符串的比较是按照字符的位置依次比较
列表---------只能在同种类型的数据情况下比较
------------ 逻辑与and
age=input(“你芳龄几何：”)
sex=input("你的性别是：")
age=int(age)
res1=age>50
res2=sex=='female'
res3=res1 and res2
print(res3)
------------逻辑或 or----成立一个条件就行
-------not true==false
------not false==true
------------------运算符优先级：自上而下，优先级从高到低
or x为真值为x，x为假，值为y print(4 or 3) print(2 or 3) print(1 or 3) print(0 or 3) print(-1 or 3) print(0 and 3 or 4 or 1 or 2) print(3 or 3 > 2) print( 3>2 or 3 ) and,x为真值为y，x为假，值为x print(4 and 3) print(2 and 3) print(1 and 3) print(0 and 3) print(-1 and 3)
逻辑运算符：(优先级) 优先级：()>not>and>or 同等优先级条件下，从左至右一次计算 print(4 > 3 or 4 < 3 and 1 != 1) 结果为True print(2 > 1 and 3 <4 or 4 > 5 and 2 < 1) 结果为False print(1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8) 结果为Flase print(1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6) 结果为False print(not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6) 结果为False 'or'：x or y 如果x为真，则值为x，否则值为y print(4 or 3) 真(True)----4 print(2 or 3) 真(True)----2 print(1 or 3) 真(True)----1 print(0 or 3) 假(False)---3 print(-1 or 3) 真(True)---- -1 'and'：x and y 如果x为真，则值为y，否则为x print(4 and 3) True----3 print(2 and 3) True----3 print(1 and 2) True----2 print(0 and 3) False----0 print(-1 and 3) True----3 int 与 bool值之间的转换 1，bool转换为int a = int(True) b = int(False) print(a,b) 2,int转换为bool a = bool(413456) b = bool(6.5) c = bool(0) d = bool(-1) print(a,b,c,d) True,True,False,True int(包含) not in(不包含) s1 = 'abcd' print('a' in sl) True print(1 and 'a' int s1) True print('ag' in s1) False print('ad' not in s1) True
八，集合--------------- 无序不重复的数据集合，集合里面的元素是可哈希的（集合本身是不可哈希的）（去重）：可以包含多个元素，用逗号分隔，
集合的三个原则：
1.每个元素都必须是不可变类型 **可变类型是不可hash类型
2.没有重复的元素（去重） **不可变类型是可hash类型
3.输出/运行的结果是无须的
定义：形如-------a={'alex','egon','wupeiqi'}
符号：{ }------------set 无须，元素关系
set-------集合是可变类型，中的元素是不可变类型
1，集合的创建
set1 = set({1,2,'barry'}) set12 ={1,2,'barry'} print(set1,type(set1),set12,type(set12))
2，集合的增
# add---增加，添加 set1 = {'alex','wusir','ritian','egon','barry'} # set1.add('金鑫') # 集合是不可变类型，所以，列表和字典不能添加 # print(set1)
linuex={'wupeiqi','egon','gangdan'}
linuex.add('马德胜') # add-----添加 set类型中的集合是可变类型
print(linuex)
#linuex.add(1,2,3) # 报错----------只能添加不可变类型
print(linuex)
# update 迭代添加 # set1.update('a') # print(set1) # # set1.update('金鑫是太白金星')
# print(set1) #{'alex', '鑫', 'wusir', '金', 'barry', '白', 'ritian', '星', 'egon', '是', '太'}
3，集合的删
set1 = {'alex','wusir','ritian','egon','barry'}
# set1.remove('alex') #根据元素删
# print(set1)
# set1.pop() #随机删除一个元素，有返回值
# print(set1)
# set1.clear() #清空集合 返回set()
# print(set1)
del set1 #直接删除集合，不留任何痕迹
# print(set1)
-------------discard--------------
linuex={'wupeiqi','egon','gangdan'} linuex.discard('wupeiqi') discard-----指定删除的元素--元素不存在报错 print(linuex)
4，集合是不可变类型，不能改（孙子，儿子均不能改）
5，集合的查
set1 = {'alex','wusir','ritian','egon','barry'}
for i in set1: #for 循环查集合的所有元素
print(i)
###求两者的共同部分：求即报名python又报名linuex的学生姓名
a={'ab','cd','ef','g','h'}
b={'cd','h','abcd'}
l=[]
for c in a:
if c in b:
l.append(c)
print(l)
求只报a没有报b的同学
a={'ab','cd','ef','g','h'}
b={'cd','h','abcd'}
l=[]
for c in a:
if c not in b:
l.append (c)
print(l)
in（包含，在） 和 not in（不包含，不在）
python={'alse','egon','yuanhao','wupeiqi','gangdan','biubiu'}
print('egon' in python)
print ('alex' and 'biubiu' in python)
print('马德胜'not in python)
print('yuanhao' not in python)
并集（l）：老男孩所有报名学生的名字集合 ----- | -----并集，合并 或 union
python={'alex','egon','yuanhao','马德胜','123'}
linuex={'马德胜','biubiu','123'}
s=python | linuex
print(s)
a={1,2,3}
b={1,3,5,8,9}
c=b |a
print(c)
交集 -------&或intersection
h1={'a','b','c'}
h2={1,'b',2,'a',3,'c'}
s=h1 & h2
print(s)
差集-------- - ---difference
l={1,2,3,4,5}
x={2,3}
b= l-x
print(b)
对称差集------ ^ ---没有同时报python和linuex的学生姓名 symmetric_difference
python={'alex','egon','yuanhao','马德胜',123}
linuex={'马德胜','biubiu',123,456}
#print(python ^ linuex)
a=python ^ linuex
print(a)
父集----->=
a={1,2,3,4}
b={2,3}
print(a>=b)----True
print(b>=a)----False
子集--------<=
a={'a','b','c'}
b={'a','b','c','d'}
print(a<=b
深浅拷贝（copy）
1，浅copy
赋值运算 # l1 = [1,2,3,['barry','alex']] # l2 = l1 # # l1[0] = 111 # l1[3][0] = 'egon' # print(l1) # print(l2) #浅拷贝: 第一层创建的是独立的内存地址，在嵌套的层级内（不管是嵌套多少层），则执行的是同一个内存空间 # l1 = [1,2,3,['barry',['kv'],'alex']] # l2 = l1.copy() # # print(l1,id(l1)) # # print(l2,id(l2)) # # # l1[1] = 222 # # l1[3][1]='123' # l1[3][1][0] = '金鑫' # print(l1,id(l1)) # print(l2,id(l2))
2，深deepcopy
#深拷贝deepcopy ------怎么样（深）都是独自的内存空间，改变不了 import copy l1 = [1,2,3,['barry',[1,'小鸡',{'k1':'k2','k2':'k3'}],'金星']] l2 = copy.deepcopy(l1) # l1[1] = 222 各自独立的内存空间 # l1[3][2] = '马德胜' # l1[3][1][1] = 'haha' l1[3][1][2]['k1'] = '深浅' print(l1,type(l1)) print(l2,type(l2))
基本数据类型之间的所有转换
int 与 Str:
int---> str：str（int） 条件：字符串必须是数字类型
str----->int ： int（str） 条件：数字必须是字符串类型
int 与 bool：
int ----->bool：除了0之外，全都是True
bool------->int ：1是True 0是False
int 与 list：之间不存在互相转换，若要将数字变成列表，必须迭代添加才行
str 与 bool：
str----->bool：bool（str） 除了空字符串，其余的都是True
bool----->str：str（bool）
str 与 list：
str------->list：split（将字符串切割）
list-------->str：join（拼接）
tuple 与 list：
tuple----------->list：list（tuple）
list ------------>tuple：tuple（list）
str 与 tuple：
str----------->tuple：tuple（str）
dict 与 list：
str，list ------------>dict：formkeys
dict------------>list：keys，values，items
*******************
数字，字符串，列表，元祖，字典对应的布尔值的False 分别是什么？（5 分） # 数字对应的布尔值False的是：0 # 字符串对应的布尔值为False的是：' '空字符串 # 列表对应的布尔值为False的是： [ ] 空列表 # 元组对应的布尔值为False的是：（）空元组 # 字典对应的布尔值为False的是： { }空字典
浙公网安备 33010602011771号