建设网站分几个步骤,创意logo图片大全,网站建设要做什么,购物小程序有哪些文章收集于网络#xff0c;如有版权#xff0c;请联系作者
一、引子
1 什么是数据#xff1f; x10#xff0c;10是我们要存储的数据 2 为何数据要分不同的类型 数据是用来表示状态的#xff0c;不同的状态就应该用不同的类型的数据去表示 3 数据类型 数字、字符串、列表…文章收集于网络如有版权请联系作者
一、引子
1 什么是数据 x1010是我们要存储的数据 2 为何数据要分不同的类型 数据是用来表示状态的不同的状态就应该用不同的类型的数据去表示 3 数据类型 数字、字符串、列表、元组、字典、集合 二、基础数据类型
2.1 数字 int
数字主要是用于计算用的使用方法并不是很多就记住一种就可以int() 可以把其他类型转化为数字类型并自动除去空格但是前提是转化的数字
# bit_length() 当十进制用二进制表示时最少使用的位数
v 11
data v.bit_length()
print(data)
2.2 布尔值bool
布尔值就两种TrueFalse
真 1 True
假 0 Falseint:0 list:[] tuple:{} str: 转化为布尔值是False其他的都是True
2.3 字符串str
2.3.1 字符串的索引与切片。
索引即下标就是字符串组成的元素从第一个开始初始索引为0以此类推。
a ABCDEFGHIJK
print(a[0]) # A
print(a[3]) # D
print(a[-1]) # K
切片就是通过索引索引索引步长截取字符串的一段形成新的字符串原则就是顾头不顾腚。
a ABCDEFGHIJK
print(a[0:3])
print(a[2:5])
print(a[0:]) # 默认到最后 ABCDEFGHIJK
print(a[0:-1]) # -1 是列表中最后一个元素的索引但是要满足顾头不顾腚的原则所以取不到K元素
print(a[0:5:2]) # 加步长 ACE
print(a[5:0:-2]) # 反向加步长 FDB
2.3.2、字符串常用方法。
# 大小写转化 captalize,swapcase,title
name flp
print(name.capitalize()) # 首字母大写
print(name.swapcase()) # 大小写翻转
msgi love china
print(msg.title()) # 每个单词的首字母大写# 内容居中 center
a1 abcdefgabcd
ret2 a1.center(20,*) # 内容居中总长度空白处填充
print(ret2)# 统计字符串出现元素个数 count
ret3 a1.count(a,0,4) # 字符串中的元素出现的个数可切片(元素开始位置结束位置)
print(ret3)# \t补全
a2 hqw\t
ret4 a2.expandtabs() # 默认将一个tab键变成8个空格如果tab前面的字符长度不足8个则补全8个如果tab键前面的字符长度超过8个不足16个则补全16个以此类推每次补全8个
print(ret4)# 判断字符串开头结尾 可切片startswithendswith
a4 dkfjdkfasf54
ret4 a4.startswith(jdk,3,6) # 判断是否以...开头顾头不顾腚返回的是布尔值
print(ret4)
ret5 a4.endswith(kfj,1,4) # 判断是否以...结尾顾头不顾腚返回的是布尔值
print(ret5)# 判断字符串中的元素是否存在 可切片find index
ret6 a4.find(fjdk,1,6) # 返回的找到的元素的索引如果找不到返回-1
print(ret6)
ret61 a4.index(fjdk,4,6) # 返回的找到的元素的索引找不到报错
print(ret61)
# 注在用find判断字符不存在时用下列的方式因为不存在返回值是-1。
# if a4.find(fjdk,1,6) -1# split 分割最终形成一个列表此列表不含有这个分割的元素。
a5 title,Tilte,atre,
ret9 a5.split(t)
print(ret9) # 结果[, i, le,Til, e,a, re,]
ret91 a5.rsplit(t,1)
print(ret91) # 结果[title,Tilte,a, re,]
ret92 a5.rsplit(t,2)
print(ret92) # 结果[title,Til, e,a, re,]# format的三种玩法 格式化输出
res{} {} {}.format(egon,18,male) # 结果 egon,18,male
res{1} {0} {1}.format(egon,18,male) # 结果 18,egon,18
res{name} {age} {sex}.format(sexmale,nameegon,age18)# strip切除字符串开头或结尾的字符
name*egon**
print(name.strip(*)) # 切除字符串开头和结尾包含的*
print(name.lstrip(*)) # 切除字符串开头包含的*
print(name.rstrip(*)) # 切除字符串结尾包含的*# replace字符串替换
nameflp China name is flp
print(name.replace(flp,shuai,1)) #要替换的字符串替换成的字符串替换的个数# is系列
nameflp123
print(name.isalnum()) # 字符串由字母或数字组成返回布尔值
print(name.isalpha()) # 字符串只由字母组成返回布尔值
print(name.isdigit()) # 字符串只由数字组成返回布尔值# 判断字符串是否为空
s
if s.strip():print(s is null)
# 或者
if not s.strip():print(s is null) 2.4 元祖tuple
元组被称为只读列表即数据可以被查询但不能被修改所以字符串的切片操作同样适用于元组。例123a,b,c 2.5 列表list
列表是python中的基础数据类型之一其他语言中也有类似于列表的数据类型比如js中叫数组他是以[]括起来每个元素以逗号隔开而且他里面可以存放各种数据类型比如
li [123,Ture,(1,2,3,’abc’),[1,2,3,’小明’,],{‘name’:’abc’}]
列表相比于字符串不仅可以储存不同的数据类型而且可以储存大量数据32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的有索引值可切片方便取值。
2.5.1、增
li [1,a,b,2,3,a]
li.insert(0,55) # 按照索引去增加
print(li) # [55, 1, a, b, 2, 3, a]li.append(aaa) # 增加到最后
li.append([1,2,3])
print(li) # [55, 1, a, b, 2, 3, a, aaa, [1, 2, 3]]li.extend([q,a,w]) # 迭代的去增
li.extend([q,a,w,aaa])
li.extend(a)
li.extend(abc)
li.extend(a,b,c)
print(li)
# [55, 1, a, b, 2, 3, a, aaa, [1, 2, 3], q,a,w, q,a,w, aaa, a, a, b, c, a, ,, b, ,, c]2.5.2、删
li [1,a,b,2,3,a]
l1 li.pop(1) # 按照位置去删除有返回值返回被删除的元素
print(l1,li) # a [1, b, 2, 3, a]del li[1:3] # 按照位置去删除也可切片删除没有返回值。
print(li) # [1, 3, a]li.remove(a) # 按照元素去删除
print(li) # [1, 3]li.clear() # 清空列表2.5.3、改
li [1,a,b,2,3,a]
li[1] dfasdfas
print(li) # [1, dfasdfas, b, 2, 3, a]li[1:3] [a,b]
print(li) # [1, a, b, 2, 3, a]2.5.4、查
切片去查或者循环去查。
2.5.5、其他操作
# count 统计某个元素在列表中出现的次数
a [q,w,q,r,t,y] print(a.count(q))
# index 用于从列表中找出某个值第一个匹配项的索引位置
a [q,w,r,t,y] print(a.index(r)) # sort 用于在原位置对列表进行排序没有返回值
a [2,1,3,4,5]
a.sort() # 他没有返回值所以只能打印排序后的a
print(a)# reverse 将列表中的元素反向存放也没有返回值
a.reverse() # 他也没有返回值所以只能打印排序后的a
print(a)2.6字典dict
字典是python中唯一的映射类型采用键值对key-value的形式存储数据。python对key进行哈希函数运算根据计算的结果决定value的存储地址所以字典是无序存储的且key必须是可哈希的。可哈希表示key必须是不可变类型如数字、字符串、元组。
字典(dictionary)是除列表外python之中最灵活的内置数据结构类型。列表是有序的对象结合字典是无序的对象集合。两者之间的区别在于字典当中的元素是通过键来存取的而不是通过偏移存取。
2.6.1、增
dic {}
dic[li] [a,b,c]
print(dic) # {li: [a, b, c]}
# setdefault 在字典中添加键值对如果键对应的值是none,则添加如果值不为空则不会更改覆盖。
dic.setdefault(k,v)
print(dic) # {age: 18, name: jin, sex: male, k: v}
dic.setdefault(k,v1)
print(dic) # {age: 18, name: jin, sex: male, k: v}2.6.2、删
dic_pop dic.pop(a,无key默认返回值) # pop根据key删除键值对并返回对应的值如果没有key则返回默认返回值
print(dic_pop)del dic[name] # 没有返回值。
print(dic)dic_pop1 dic.popitem() # 随机删除字典中的某个键值对将删除的键值对以元祖的形式返回
print(dic_pop1) dic_clear dic.clear() # 清空字典
print(dic,dic_clear) # {} None注在循环字典本身的时候不能删除字典的键值对
2.6.3、改
dic {name:jin,age:18,sex:male}
dic2 {name:alex,weight:75}
dic2.update(dic) # 将dic所有的键值对覆盖添加相同的覆盖没有的添加到dic2中
print(dic2) # {name: jin, weight: 75, age: 18, sex: male}2.6.4、查
value1 dic[name] # 没有会报错
print(value1)value2 dic.get(djffdsafg,默认返回值) # 没有可以返回设定的返回值
print(value2)2.6.5、其他操作
item dic.items()
print(item,type(item))
# dict_items([(age, 18), (sex, male)) class dict_items这个类型就是dict_items类型可迭代的keys dic.keys()
print(keys,type(keys)) # dic的所有kvalues dic.values()
print(values,type(values)) # dic的所有值# 字典的循环。
dic {age:18,sex:male}
for key in dic:print(key)
for item in dic.items():print(item)
for key,value in dic.items():print(key,value)# 判断值是否在字典中
if age in dic.keys:
if age in dic:# fromkeys(seq[, value]) 函数用于创建一个新字典以序列 seq 中元素做字典的键value 为字典所有键对应的初始值。
dict.fromkeys(seq[, value])seq -- 字典键值列表。value -- 可选参数, 设置键序列seq的值。seq (Google, Runoob, Taobao)
dict dict.fromkeys(seq)
print 新字典为 : %s % str(dict)
# 新字典为 : {Google: None, Taobao: None, Runoob: None}dict dict.fromkeys(seq, 10)
print 新字典为 : %s % str(dict)
# 新字典为 : {Google: 10, Taobao: 10, Runoob: 10}2.7 集合set
集合可变的数据类型他里面的元素必须是不可变(可哈希)的数据类型无序不重复
去重把一个列表变成集合会自动去重
关系测试是测试两组数据之前的交集差集并集等关系
创建
set1 set(1,2,abc)
增
set1.add(dong)
set1.update([1,2,3])
删
set1.remove(a) # 删除一个元素
set1.pop(b) # 随机删除一个有返回值返回值为删除的元素
set1.clear() # 清除set
del set1 # 删除set1查
for i in set1 :print(i)
关系测试
set1 {1,2,3,4,a}
set2 {a,b,c,d,1}
print(set1 set2)
print(set1.intersection(set2)) # 交集{1, a}print(set1 | set2)
print(set2.union(set1)) # 并集{1, 2, 3, 4, d, b, c, a}print(set1 - set2)
print(set1.symmetric_difference(set2)) # 差集set1独有的{2, 3, 4}print(set1 ^ set2)
print(set1.difference(set2)) # 反交集{2, 3, 4, c, d, b}print(set1 set2)
print(set1.issubset(set2)) # 这两个相同都是说明set1是set2子集。print(set2 set2)
print(set2.issuperset(set1)) # 这两个相同都是说明set2是set1超集。三丶基础数据类型的总结
按存储空间的占用分从低到高 数字 字符串 集合无序即无序存索引相关信息 元组有序需要存索引相关信息不可变 列表有序需要存索引相关信息可变需要处理数据的增删改 字典无序需要存key与value映射的相关信息可变需要处理数据的增删改 按存值个数区分 标量原子类型 数字字符串 容器类型 列表元组字典
按可变不可变区分 可变 列表字典 不可变 数字字符串元组布尔值
按访问顺序区分 直接访问 数字 顺序访问序列类型 字符串列表元组 key值访问映射类型 字典
四丶其他forenumeraterange
for循环用户按照顺序循环可迭代对象的内容。
msg Lepeng最帅
for item in msg:print(item)li [赵,钱,孙,李]
for i in li:print(i)dic {name:Lepeng,age:18,sex:man}
for k,v in dic.items():print(k,v)enumerate枚举对于一个可迭代的iterable/可遍历的对象如列表、字符串enumerate将其组成一个索引序列利用它可以同时获得索引和值。
li [赵,钱,孙,李]
for i in enumerate(li):print(i)
for index, name in enumerate(li, 100): # 起始位置默认是0可更改print(index, name)
# 100 赵
# 101 钱
# 102 孙
# 103 李range指定范围生成指定数字。
for i in range(1,10):print(i)for i in range(1,10,2): # 步长print(i)join用于将序列中的元素以指定的字符连接生成一个新的字符串。 语法 sep.join(seq) 参数说明 sep分隔符可以为空 seq要连接的元素序列、字符串、元组、字典 上面的语法即以sep作为分隔符将seq所有的元素合并成一个新的字符串,然后返回 示例
s1 -
s2
seq (r, u, n, o, o, b) # 字符串序列
print (s1.join( seq )) # r-u-n-o-o-b
print (s2.join( seq )) # runoob五判断是否是字符串字典等isinstance
在实际写程序中经常要对变量类型进行判断除了用type(变量)这种方法外还可以用isinstance方法判断
#!/usr/bin/env python
a 1
b [1,2,3,4]
c (1,2,3,4)
d {a:1,b:2,c:3}
e abc
if isinstance(a,int):print a is int
else:print a is not int
if isinstance(b,list):print b is list
else:print b is not list
if isinstance(c,tuple):print c is tuple
else:print c is not tuple
if isinstance(d,dict):print d is dict
else:print d is not dict
if isinstance(e,str):print d is str
else:print d is not str六丶相互转化
# 1、字典
dict1 {name: Zara, age: 7, class: First}
# 字典转为字符串返回type str {age: 7, name: Zara, class: First}
print(type(str(dict1)), str(dict1))
# 字典可以转为元组返回(age, name, class)
print(tuple(dict1))
# 字典可以转为元组返回(7, Zara, First)
print(tuple(dict1.values()))
# 字典转为列表返回[age, name, class]
print(list(dict1))
# 字典转为列表返回[Zara, 7, First]
print(list(dict1.values()))# 2、元组
tup(1, 2, 3, 4, 5)
# 元组转为字符串返回(1, 2, 3, 4, 5)
print(tup.__str__())
# 元组转为列表返回[1, 2, 3, 4, 5]
print(list(tup))
# 元组不可以转为字典# 3、列表
nums[1, 3, 5, 7, 8, 13, 20];
# 列表转为字符串返回[1, 3, 5, 7, 8, 13, 20]
print(str(nums))
# 列表转为元组返回(1, 3, 5, 7, 8, 13, 20)
print(tuple(nums))
# 列表不可以转为字典# 4.1、字符串之eval函数此函数有风险需慎用此函数的参数可以是系统命令所以会存在风险
# 字符串转为元组前提是字符串像元组,返回(1, 2, 3)
print(eval((1,2,3)))
# 字符串转为列表前提是字符串像列表,返回[1, 2, 3]
print(eval([1,2,3]))
# 字符串转为字典前提是字符串像字典,返回{name: ljq, age: 24}
print(eval({name:ljq, age:24}))# 4.2、字符串转换其他方式
# 字符串转为列表结果[, i, le,Til, e,a, re,]
a5 title,Tilte,atre,
print(a5.split(t))# 字符串转为字典
s Name1Value1;Name2Value2;Name3Value3
d dict(item.split() for item in s.split(;))
print(d)
# 结果为dict { Name1: Value1, Name2: Value2, Name3: Value3 }
# 注意s结尾不能是;如果是用s.rstrip(;)
七注意事项
如果元组只有一个元素如果不加逗号此元素是什么类型则就是什么类型如果元组只用表示也不存在此情况list字典不存在此情况
tu1 () # class tuple
tu2 (1) # class int
tu3 (1,) # class tuplelist1 [a] # class list
list2 [] # class list
八丶深浅copy
1先看赋值运算
l1 [1,2,3,[AB,ab]]
l2 l1l1[0] 111
print(l1) # [111, 2, 3, [AB, ab]]
print(l2) # [111, 2, 3, [AB, ab]]l1[3][0] EEE
print(l1) # [111, 2, 3, [EEE, ab]]
print(l2) # [111, 2, 3, [EEE, ab]]
对于赋值运算来说l1与l2指向的是同一个内存地址所以他们是完全一样的。
2浅拷贝copy
# 同一代码块下
l1 [1, abc, True, (1,2,3), [22, 33]]
l2 l1.copy()
print(id(l1), id(l2)) # 2713214468360 2713214524680 不同
print(id(l1[-2]), id(l2[-2])) # 2547618888008 2547618888008 相同
print(id(l1[-1]),id(l2[-1])) # 2547620322952 2547620322952 相同# 不同代码块下
l1 [1, abc, True, (1, 2, 3), [22, 33]]
l2 l1.copy()
print(id(l1), id(l2)) # 1477183162120 1477183162696 不同
print(id(l1[-2]), id(l2[-2])) # 1477181814032 1477181814032 相同
print(id(l1[-1]), id(l2[-1])) # 1477183162504 1477183162504 相同
对于浅copy来说只是在内存中重新创建了开辟了一个空间存放一个新列表但是新列表中的元素与原列表中的元素是公用的。
3深拷贝deepcopy。
# 同一代码块下
import copy
l1 [1, abc, True, (1,2,3), [22, 33]]
l2 copy.deepcopy(l1)
print(id(l1), id(l2)) # 2788324482440 2788324483016 不同
print(id(l1[0]),id(l2[0])) # 1470562768 1470562768 相同
print(id(l1[-1]),id(l2[-1])) # 2788324482632 2788324482696 不同
print(id(l1[-2]),id(l2[-2])) # 2788323047752 2788323047752 相同# 不同代码块下
import copy
l1 [1, abc, True, (1, 2, 3), [22, 33]]
l2 copy.deepcopy(l1)
print(id(l1), id(l2)) # 1477183162824 1477183162632 不同
print(id(0), id(0)) # 1470562736 1470562736 相同
print(id(-2), id(-2)) # 1470562672 1470562672 相同
print(id(l1[-1]), id(l2[-1])) # 1477183162120 1477183162312 不同
对于深copy来说列表是在内存中重新创建的列表中可变的数据类型是重新创建的列表中的不可变的数据类型是公用的。
八、小数据池
小数据池。 一种数据缓存机制. 也被称为驻留机制. 各大编程语⾔中都有类似的东西.
小数据池只针对: 整数, 字符串, 布尔值. 其他的数据类型不存在如列表元祖等即使里面只有一个值赋值时内存地址不一样
在python中对-5到256之间的整数会被驻留留在内存中. 将一定规则的字符串缓存. 在使用的时候, 内存中只会创建一个该数据的对象. 保存在小数据池中. 当使用的时候直接从小数据池中获取对象的内存引用. 而不需要创建一个新的数据. 这样会节省更多的内存区域. 优点: 能够提⾼一些字符串, 整数的处理速度. 省略创建对象的过程. 缺点: 在’池’中创建或者插入新的内容会花费更多的时间. 对于数字: -5~256是会被加到小数据池中的. 每次使用都是同一个对象. 例如 a,b100,100 print(a is b) #True 对于字符串: 如果字符串的长度是0或者1, 都会默认进行缓存 字符串长度大于1, 但是字符串中只包含字母, 数字, 下划线时才会缓存无论字符串长度大小 用乘法得到的字符串. ①. 乘数等于1, 仅包含数字, 字母, 下划线时会被缓存. 如果包含其他字符, 而长度1 也会被驻存, ②. 乘数大于1, 仅包含数字, 字母, 下划线时会被缓存. 但字符串长度不能大于20 大于20不会缓存 指定驻留. 我们可以通过sys模块中的intern()函数来指定要驻留留的内容. 到目前为止. 我们已经了解了了python的小数据池的一些基本情况了. 但是!!!! 还有最后一 个问题. 小数据池和最开始的代码块有什么关系呢? 同样的一段代码在命令行窗口和在py文件中. 出现的效果是完全不一样的。在代码块内的缓存机制是不一样的.
在执行同一个代码块的初始化对象的命令时, 会检查其值是否已经存在, 如果存在, 会将其重用. 换句话说: 执行同一个代码块时, 遇到初始化对象的命令时他会将初始化的这个变量与值存储在一个字典中, 在遇到新的变量时, 会先在字典中查询记录, 如果有同样的记录那么它会重复使用这个字典中的之前的这个值. 所以在文件执行时(同一个代码块) 会把a, b两个变量量指向同⼀一个对象.如果是不同的代码块, 他就会看这个两个变量是否满足小数据池的数据, 如果是满足小数据池的数据则会指向同一个地址. a, b的赋值语句分别被当作两个代码块执行, 但是他们不满足小数据池的数据所以会得到两个不同的对象, 因而is判断返回False.为赋值赋予的是内存地址 is比较的是内存地址。 id比较的id是否相同。 比较两个值是否相等。
