python基本数_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 inli: #循环查找

# 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 indic1: #获取所有的键(key)

# print(key)

#for key indic1.keys(): #获取所有的key

# print(key)

#2，

#for value indic1.values(): #获取所有的值(value)

# print(value)

#3，

#for item indic1.items(): #以元组的形式获取元素

# print(item)

#4，

#for key,value indic1.items(): #获取元组

# print(key,value)

for ------循环

for循环：用户按顺序循环可迭代对象的内容

# msg= '老男孩python是全国范围内最好的python培训机构'#for item inmsg: #循环遍历字符串的每一个元素

# print(item)

# li= ['alex','银角','女神','爱根','太白']

#for i inli: #遍历列表的每一个元素

# print(i)

# dic= {'name':'太白','age':18,'sex':'man'}

#for k,y indic.items():

# print(k,y)

enumerate----枚举

# enumerate----枚举 (同时可以获得索引和值)

li= ['alex','银角','女神','爱根','太白']

#for i inenumerate(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)

逻辑and 和 or

逻辑运算符：(优先级)

优先级：()>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(not2 > 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)----4print(2 or 3) 真(True)----2print(1 or 3) 真(True)----1print(0 or 3) 假(False)---3print(-1 or 3) 真(True)---- -1

'and'：x and y 如果x为真，则值为y，否则为x

print(4 and 3) True----3print(2 and 3) True----3print(1 and 2) True----2print(0 and 3) False----0print(-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,Trueint(包含) not in(不包含)

s1= 'abcd'print('a' insl) True

print(1 and 'a' ints1) True

print('ag' ins1) 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 ina:if c inb:

l.append(c)print(l)

求只报a没有报b的同学

a={'ab','cd','ef','g','h'}

b={'cd','h','abcd'}

l=[]for c ina:if c not inb:

l.append (c)print(l)

in(包含，在)   和    not  in(不包含，不在)

python={'alse','egon','yuanhao','wupeiqi','gangdan','biubiu'}print('egon' inpython)print ('alex' and 'biubiu' inpython)print('马德胜'not inpython)print('yuanhao' not in python)

并集(l)：老男孩所有报名学生的名字集合      -----  |  -----并集，合并 或  union

python={'alex','egon','yuanhao','马德胜','123'}

linuex={'马德胜','biubiu','123'}

s=python |linuexprint(s)

a={1,2,3}

b={1,3,5,8,9}

c=b |aprint(c)

交集 -------&或intersection

h1={'a','b','c'}

h2={1,'b',2,'a',3,'c'}

s=h1 &h2print(s)

差集-------- - ---difference

l={1,2,3,4,5}

x={2,3}

b= l-xprint(b)

对称差集------ ^ ---没有同时报python和linuex的学生姓名  symmetric_difference

python={'alex','egon','yuanhao','马德胜',123}

linuex={'马德胜','biubiu',123,456}#print(python ^ linuex)

a=python ^linuexprint(a)

父集----->=

a={1,2,3,4}

b={2,3}print(a>=b)----Trueprint(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的是： { }空字典