Python--基础二
Python基础:字符串str & 列表list & 元组tuple & 字典dict & 集合set
Python 基础 2
字符串 str
字符串是以单引号或双引号括起来的任意文本
字符串不可变
创建字符串
str1 = "lee is a good man!"
str2 = "lee is a nice man!"
str3 = "lee is a handsome man!"
字符串运算
字符串拼接
str6 = "lee is a "
str7 = "good man"
str8 = str6 + str7
print("str6 =", str6)
print("str7 =", str7)
print("str8 =", str8) a="hello"+"-"*50+"world"
print(a)
print(a.__len__())
print(len(a))
输出重复字符串
输出重复字符串
str9 = "good"
str10 = str9 * 3
print("str10 =", str10)
访问字符串中的某一个字符
通过索引下标查找字符
字符串名[下标]
str11 = "lee is a good man!"
print(str11[1])
#str11[1] = "a" #打印会报错,因为字符串不可变
#print("str11 =", str11)
字符串取值(切片)
str12 = "to day is a good day"
print(str12[5:10]) # 从给定下标开始截取到给定下标之前
print(str12[:4]) # 从头截取到给定下标之前
print(str12[14:]) # 从给定下标处开始截取到结尾
print(str12[:]) # :号前后都省略,则表示全取列表所有的值;但这样写比较怪,不如直接print(str12)
print(str12[::2]) # 第一个:号前后都省略,表示全取,第二个:号后的数字2表示步长(和循环里的步长一致)
print(str12[::-1]) #列表反转,类似os.reverse()
字符串判断
str13 = "lee is a good man!"
print("good" in str13)
print("good" not in str13)
格式化输出
print("lee is a good man")
num = 10
str14 = "lee is a nice man!"
f = 10.14567
print("num =", num)
# %d %s %f 占位符
# %.2f 精确到小数后2位,会四舍五入
print("num = %d, str14 = %s, f = %.2f" %(num,str14,f))
字符串的方法
abc=" Hello,nice to meet you "
print(len(abc)) # 打印字符串的长度
print(abc.__len__()) # 打印字符串的长度
print(abc.lower()) # 转换字符串中大写字母为小写字母
print(abc.upper()) # 转换字符串中小写字母为大写字母
print(abc.swapcase()) # 转换字符串中大写字母为小写字母,小写字母为大写字母
print(abc.capitalize()) # 整个字符串中首字母大写,其他全部小写
print(abc.title()) # 每个单词的首字母大写
print(abc.center(50, "*")) # 一共50个字符,字符串放中间,不够的两边补*
print(abc.ljust(50, "*")) # 一共50个字符,字符串放左边,不够的左边补*
print(abc.rjust(50, "*")) # 一共50个字符,字符串放右边,不够的右边补*
print(abc.zfill(50)) # 一共50个字符,字符串放右边,不够的右边补0
print(abc.count("t")) # 统计字符串里t出现了多少次
print(abc.find("to")) # 找出to在字符串中的第几位
print(abc.rfind("to")) # 找出最后一个to在字符串中的第几位
print(abc.index("to")) # 和find一样的查找,只不过如果to不存在的时候会报一个异常
print(abc.rindex("to")) # 和rfind一样的查找,只不过如果to不存在的时候会报一个异常
print(abc.endswith("you")) # 判断是否以you结尾
print(abc.startswith("Hello")) # 判断字符串是否以hello开始
print(abc.isalnum()) # 判断字符串中是否只有字母或数字
print(abc.isalpha()) # 判断字符串是否都是字母
print(abc.isdecimal()) # 判断字符串中是否只包含十进制字符
print(abc.isdigit()) # 判断字符串中是否只有数字
print(abc.islower()) # 判断字符串中的字符是否都是小写的英文字母
print(abc.isnumeric()) # 判断字符串中是否只有数字
print(abc.isspace()) # 判断字符串中是否只包含空格 print(abc.strip()) # 去掉字符串左右两端的空格或换行
print(abc.lstrip()) # 去掉字符串左边空格或换行
print(abc.rstrip()) # 去掉字符串右边空格或换行
# eval(str)
# 功能:将字符串str当成有效的表达式来求值并返回计算结果
print(eval("+123"))
print(eval("-123"))
print(eval("12+3"))
print(eval("12-3")) # len(str)
# 返回字符串的长度(字符个数)
print(len("lee is a good man!")) # lower()
# 转换字符串中大写字母为小写字母
str15 = "LEE is a Good Man!"
print(str15.lower()) # upper()
# 转换字符串中小写字母为大写字母
str16 = "LEE is a Good Man!"
print(str16.upper())
print("LEE is a Good Man!".upper()) # swapcase()
# 转换字符串中大写字母为小写字母,小写字母为大写字母
str17 = "LEE is a Good Man!"
print(str17.swapcase()) # capitalize()
# 首字母大写,其他小写
str18 = "LEE is a Good Man!"
print(str18.capitalize()) # title()
# 每个单词的首字母大写
str19 = "LEE is a Good Man!"
print(str19.title()) # center(width[,fillchar])
# 返回一个指定宽度的居中字符串,fillchar为填充的字符串,默认是空格填充
str20 = "lee is a nice man!"
print(str20.center(40,"*")) # ljust(width[,fillchar])
# 返回一个指定宽度的左对齐字符串,fillchar为填充的字符串,默认是空格填充
str21 = "lee is a nice man!"
print(str21.ljust(40,"%")) # rjust(width[,fillchar])
# 返回一个指定宽度的右对齐字符串,fillchar为填充的字符串,默认是空格填充
str22 = "lee is a nice man!"
print(str22.rjust(40,"%")) # zfill(width)
# 返回一个长度为width的字符串,原字符串右对齐,前面补0
str23 = "lee is a nice man!"
print(str23.zfill(40)) # count(str[,start][,end])
# 返回字符串中strc出现的次数,可以指定一个范围,默认从头到尾
str24 = "lee is a very very nice man!"
print(str24.count("very"))
print(str24.count("very",9,len(str24))) # find(str[,start][,end])
# 从左向右检测str字符串是否包含在字符串中,可以指定范围,默认从头到尾,得到的是第一次出现的开始下标,没有返回-1
str25 = "lee is a very very nice man!"
print(str25.find("very"))
print(str25.find("good"))
print(str25.find("very",8,len(str25))) # rfind(str[,start][,end])
str25 = "lee is a very very nice man!"
print(str25.rfind("very"))
print(str25.rfind("good"))
print(str25.rfind("very",8,len(str25))) # index(str,start=0,end=len(str))
# 跟find()一样,只不过如果str不存在的时候会报一个异常
str26 = "lee is a very very nice man!"
print(str26.index("very")) # rndex(str,start=0,end=len(str))
# 跟rfind()一样,只不过如果str不存在的时候会报一个异常
str27 = "lee is a very very nice man!"
print(str27.rindex("very")) # lstrip()
# 截掉字符串左侧指定的字符,默认为空格
str28 = "*******lee is a nice man!"
print(str28.lstrip("*")) # rstrip()
# 截掉字符串右侧指定的字符,默认为空格
str29 = "lee is a nice man! "
print(str29.rstrip(),"*") # strip()
# 截掉字符串两侧指定的字符,默认为空格
str30 = "******lee is a nice man******"
print(str30.strip("*")) # 应用, 模拟用户登录. 忽略用户输入的空格
username = input("请输入用户名:").strip()
password = input("请输入密码: ").strip()
if username == 'xiaobai' and password == '':
print("登录成功")
else:
print("登录失败") # split(str="",num)
# 以str为分隔符截取字符串,指定num,则仅截取num个字符串
str31 = "lee***is*****a**good**man"
print(str31.split("*"))
list39 = str31.split("*")
c = 0
for s in list39:
if len(s) > 0:
c += 1
print(c) # splitlines([keepends])
# 按照('\r', '\r\n', '\n')分割
# keepends == True 会保留换行符
str32 = '''
lee is a good man!
lee is a nice man!
lee is a handsome man!
'''
print(str32.splitlines()) # join(seq)
#以指定的字符串分隔符,将seq中的所有元素组合成一个字符串
list33 = ['lee','is','a','good','man']
str33 = " ".join(list33)
print(str33) # max() min()
str34 = "lee is a good man z"
print(max(str34))
print("*"+min(str34)+"*") # replace(oldstr,newstr,count)
# 用newstr替换oldstr,默认是全部替换。如果指定了count,那么只替换前count个
str35 = "lee is a good good good man"
str36 = str35.replace("good","nice",1)
print(str36) # 创建一个字符串映射表
# 要转换的字符串, 目标字符串
str37 = str.maketrans("ac","")
# a--6 c--5
str38 = "lee is a good man"
str39 = str38.translate(str37)
print(str39) # startswith(str,start=0,end=len(str))
# 在给定的范围内是否是以给定的字符串开头的,如果没有指定范围,默认整个字符串
str40 = "lee is a good man"
print(str40.startswith("lee",5,14)) # endswith(str,start=0,end=len(str))
# 在给定的范围内是否是以给定的字符串结尾的,如果没有指定范围,默认整个字符串
str41 = "lee is a good man"
print(str41.endswith("man")) # 编码
#encode(encoding="utf-8",errors="strict")
str42 = "lee is a good man杰"
#ignore 忽略错误
date42 = str42.encode("utf-8","ignore")
print(date42) # 解码 注意:要与编码时的编码格式一致
str43 = date42.decode("gbk","ignore")
print(str43) # isalpha()
# 如果字符串中至少有一个字符且所有的字符都是字母返回True,否则返回False
str44 = "leeisagoodman"
print(str44.isalpha()) # isalnum()
# 如果字符串中至少有一个字符且所有的字符都是字母或数字返回True,否则返回False
str45 = "12a3"
print(str45.isalnum()) # isupper()
# 如果字符串中至少有一个英文字符且所有的字符都是大写的英文字母返回True,否则返回False
print("ABD".isupper())
print("AbC".isupper())
print("ABC".isupper())
print("ABD#".isupper()) # islower()
# 如果字符串中至少有一个英文字符且所有的字符都是小写的英文字母返回True,否则返回False
print("abc".islower())
print("Abcd".islower())
print("ABCD".islower())
print("abc1".islower())
print("abc!".islower()) # istitle()
# 如果字符串是标题化的返回True,否则返回False
print("Lee Is".istitle())
print("Lee is".istitle())
print("lee is".istitle()) # isdigit()
# 如果字符串只包含数字字符返回True,否则返回False
print("".isdigit())
print("123a".isdigit() # isnumeric()
# 同上
print("".isnumeric())
print("123s".isnumeric()) # isdecimal()
# 字符串中只包含十进制字符
print("".isdecimal())
print("123a".isdecimal()) # 如果字符串中只包含空格返回True,否则返回False
print(" ".isspace())
print(" ".isspace())
print("\t".isspace())
print("\n".isspace())
print("\r".isspace())
字符串方法示例大全
列表 list
列表是一种基本的序列数据结构,是一种可变值的数据类型;使用中括号表示[]
列表中的每个元素配有下标(或者叫索引); 第一个为0,第二个为1,以此类推,每个元素用逗号隔开,里面可以存放各种数据类型比如:
li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]
格式:列表名 = [ 列表选项1, 列表选项2, ,,,,,, 列表选项n]
#创建一个空列表
list1 = []
print(list1) #创建带有元素的列表
list2 = [18, 19, 20, 21, 22]
index = 0
sum = 0
#嵌套最好不要超过3层
while index < 5:
sum += list2[index]
index += 1
if index == 5:
print("平均年龄:%d" %(sum / 5))
#注意:列表中的元素数据可以是不同类型的
list3 = [1, 2, 3, "lee", "good", True]
print(list3)
增:
# 在列表的末尾添加新的元素
list12 = [1,2,3,4,5]
list12.append(6)
list12.append([7,8,9])
print(list12) # 在末尾一次性追加另一个列表中的多个值
list13 = [1,2,3,4,5]
list13.extend([6,7,8]) # 迭代的去增
print(list13) # 根据索引增加,不覆盖原数据,原数据向后顺延
list14 = [1,2,3,4,5]
list14.insert(3,100)
list14.insert(3,[44,22])
print(list14)
删:
# pop(x=list[-1])
# 移除列表中指定下标处的元素(默认移除最后一个元素),并返回删除的数据
list15 = [1,2,3,4,5]
list15.pop()
list15.pop(2)
print(list15.pop(1))
print(list15) # remove 移除列表中的某个元素第一个匹配的结果
list16 = [1,2,3,4,5,6,3,4,2]
list16.remove(4)
print(list16) # 按照位置去删除,也可切片删除没有返回值
# del li[1:3]
# print(li) # 清除列表中所有的数据
list17 = [1,2,3,4,5]
list17.clear()
print(list17)
改:
li = [1, 'a', 'b', 2, 3, 'a']
li[1] = "test"
print(li)
>打印结果
[1, 'test', 'b', 2, 3, 'a'] li[1:3] = ['A', 'B']
print(li)
>打印结果
[1, 'A', 'B', 2, 3, 'a']
查:
可以通过切片查, 或者通过循环去查
#列表元素的访问
#注意不要越界(下标超出了可表示的范围)
#取值 格式:列表名[下标]
list4 = [1, 2, 3, 4, 5]
print(list4[2]) os=["rhel","centos","suse"]
print(len(os)) #打印列表里元素的个数
print(max(os)) #打印最大元素
print(min(os)) #打印最小元素
print(os[0]) #取列表中的第一个
print(os[1]) #取列表中的第二个
print(os[2]) #取列表中的第三个
print(os[1:3]) #取列表中的第二个到第三个(注意:不包含第四个)
print(os[0:-1]) #取列表中的第一个到倒数第二个(注意:不包含最后一个)
print(os[2:]) #取列表中的第三个到最后一个
print(os[:2]) #取列表中的第一个到第二个(注意:不包含第三个)
print(os[:]) # :号前后都省略,则表示全取列表所有的值;但这样写比较怪,不如直接print(os)
print(os[::2]) # 第一个:号前后都省略,表示全取,第二个:号后的数字2表示步长(和循环里的步长一致)
print(os[::-1]) #列表反转,类似os.reverse()
其他方法
# 从列表中找出某个值第一个匹配的索引值
list18 = [1,2,3,4,5,3]
index18 = list18.index(3)
index19 = list18.index(3,3,6)
print(index18)
print(index19) # 列表中元素的个数
list20 = [1,2,3,4,5]
print(len(list20)) # 获取列表中的最大值
list21 = [1,2,3,4,5]
print(max(list21) # 获取列表中的最小值
list22 = [1,2,3,4,5]
print(min(list22)) # 倒序
list25 = [1,2,3,4,5]
list25.reverse()
print(list25) # 升序排序
list26 = [2,3,4,1,5]
list26.sort()
print(list26)
#找出第二大的值
# 方法一
listNum = []
num = 0
while num < 10:
val = int(input())
listNum.append(val)
num += 1
print(listNum)
listNum.sort() #按照升序排序
count = listNum.count(listNum[len(listNum) -1])
c = 0
while c < count:
listNum.pop()
c += 1
print(listNum[len(listNum) -1]) # 方法二
listNum = []
num = 0
while num < 10:
val = int(input())
listNum.append(val)
num += 1 if listNum[0] >= listNum[1]:
max = listNum[0]
sec = listNum[1]
else:
max = listNum[1]
sec = listNum[0] index = 2
while index < len(listNum):
if listNum[index] >= sec:
sec = listNum[index]
if listNum[index] >= max:
sec = max
max = listNum[index]
index += 1
print(sec)
列表练习
元组 tuple
元组也是一种有序集合,与列表相似,一旦初始化就不能修改,使用小括号表示 ()
#创建tuple
#格式:元组名 = (元组元素1, 元组元素2, ……, 元组元素n) #创建空的元组
tuple1 = ()
print(tuple1) #创建带有元素的元组
#元组中的元素的类型可以不同
tuple2 = (1,2,3,"good",True)
print(tuple2) #定义只有一个元素的元组
tuple3 = (1,)
print(tuple3)
print(type(tuple3))
元组的访问
# 元组元素的访问
# 格式:元组名[]
# 下标从0开始
tuple4 = (1,2,3,4,5)
print(tuple4[1])
print(tuple4[-1]) # 获取最后一个元素
print(tuple4[-2]) # 元组的截取
# 格式:元组名[开始下标:结束下标]
# 从开始下标开始截取,截取到结束下标之前
tuple12 = (1,2,3,4,5,6,7,8)
print(tuple12[3:7])
print(tuple12[3:])
print(tuple12[:7]) # 二维元组:元素为一维元组的元组
tuple13 = ((1,2,3),(4,5,6),(7,8,9))
print(tuple13[1][1]) # 判断元素是否在元组中
tuple11 = (1,2,3)
print(4 in tuple11)
元组的方法
#len() 返回元组中元素的个数
tuple14 = (1,2,3,4,5)
print(len(tuple14)) #max() 返回元组中的最大值
print(max((5,6,7,8,9)))
#min() 返回元组中的最小值
print(min(1,2,3,4,5)) #将列表转成元组
list1 = [1,2,3]
tuple15 = tuple(list1)
print(tuple15) #元组的遍历
for i in (1,2,3,4,5):
print(i)
删除元组
tuple6 = (1,2,3)
del tuple6
#print(tuple6)
字典 dict
字典是python中唯一的映射类型,采用键值对(key-value)的形式存储数据。python对key进行哈希函数运算,根据计算的结果决定value的存储地址,所以字典是无序存储的,且key必须是可哈希的。可哈希表示key必须是不可变类型,如:数字、字符串、元组。
字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。
{Key1:value2, Key2:value2}
键与值用冒号“:”分开;
项与项用逗号“,”分开;
key的特性
1、字典中的key必须唯一
2、key是不可变的对象
3、字符串、数字等都是不可变的,可以作为key
4、list是可变的,不能作为key
思考:保存多位学生的姓名与成绩
[["tom",60],["lilei",70]]
使用字典,学生姓名为key,学生成绩作为值
dict1 = {"tom":60, "lilei":70}
增:
dict1= {'stu01':'yun', 'stu02':'yu'}
dict1["stu05"]="tianqi" #类似修改,如果key值不存在,则就增加
print(dict1) # 如果dict中没有出现过这个key-value. 可以通过setdefault设置默认值 .setdefault(key, value)
dict1.setdefault("stu06", 'xue') # 也可以往⾥⾯设置值, 如果dict中已经存在了,那么setdefault将不会起作用
print(dict1)
删:
dict1.pop("stu05") # 删除这条记录值,返回删除的value del dict1["stu05"] # 删除这条记录值, dict1.popitem() # 删除显示的最后一条 dict1.clear() # 清空字典
改:
dic = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic2.update(dic) # 将dic所有的键值对覆盖添加(相同的覆盖,没有的添加)到dic2中
print(dic2) dict1["stu04"]="马六" #类似增加,如果key值存在,则就修改
print(dict1)
查:
print(dict1["stu01"]) #不建议这种方法,如果key值不存在,会返回keyerror错误 print(dict1.get("stu01")) #这种取值方法如果key值不存在,会返回none,不会返回错误
其他操作
print("stu01" in dict1) #判断键stud01是否在字典里,在则返回True,不在则返回False print(dict1.items()) #字典转成列表套元组 print(list(dict1)) #这种只能看到key print(dict1.keys()) #打印所有的keys print(dict1.values()) #打印所有的values dict1.setdefault("stu08","老八") #有这个key,则不改变;没有这个key,则增加这个key和value # if "stu08" in dict1:
# pass
# else:
# dict1["stu08"]="老八" #这个判断也可以实现setdefault的方法效果
字典的循环
dict1 = {
'stu01':"zhangsan",
'stu02':"lisi",
'stu03':"wangwu",
'stu04':"maliu",
} #建议用这种来做字典循环,效率高
for i in dict1:
print(i,dict1[i]) #这种循环效率比上面的差
for i,j in dict1.items():
print(i,j) #只循环key
for i in dict1.keys():
print(i) #只循环value
for i in dict1.values():
print(i)
字典的嵌套
dic = {'name':'汪峰',
'age':43,
'wife':{
'name':'国际章',
'age':39,
'salary':100000
},
'baby':[
{'name':'熊大','age':18},
{'name':'熊二','age':15},
]
} #找到熊大的年龄
print(dic['baby'][0]['age'])
#将熊大年龄改为19岁
dic['baby'][0]['age'] = 19
print(dic)
字典和列表的比较
#dict
#1、查找和插入的速度极快不会随着key-vaule的增加而变慢
#2、需要占用大量的内存,内存浪费多 #list
#1、查找和插入的速度会随着数据量的增多而减慢
#1、占用空间小,浪费内存少
# 输入一个单词,判断出现了多少次
w = input()
d = {} # word:次数
str = "lee is a good man! lee is a nice man! lee is a greate man! lee is a hands man! lee is a good man! lee is a noble man!" l = str.split(" ")
for v in l:
c = d.get(v)
if c == None:
d[v] = 1
else:
d[v] += 1
print(d[w]) '''
1、以空格切割字符串
2、循环处理列表中的每个元素
3、以元素当做key去一个字典中提取数据
4、如果没有提取到,就以该元素作为key,1作为value存进字典
5、如果提取到,将对应的key的value修改,值加1
6、根据输入的字符串当做key再去字典取值
'''
字典练习
集合 set
set类似dict,是一组key的集合,不存储value
本质:无序和无重复元素的集合
#创建
#创建set需要一个list或者tuple或者dict作为输入
#重复元素在set中会自动被过滤
set1 = set([1,2,3,4,5,5,4,3,3])
print(set1) set2 = set((1,2,3,4,3,2))
print(set2) set3 = set({1:"good",2:"nice"})
print(set3)
增:
# add , update
set4 = set([1,2,3,4,5])
set4.add(6)
set4.add(4) #可以添加重复的,但是不会有效果
#set4.add([7,8,9]) #set的元素不能是列表,因为列表是可变的
set4.add((7,8,9))
#set4.add({4:"good"}) #set的元素不能是字典,因为字典也是可变的
print(set4) #插入整个list、tuple、字符串,打碎插入
set5 = set([1,2,3,4,5])
set5.update([6,7,8])
set5.update((9,10))
set5.update("sunck")
print(set5)
删:
set6 = set([1,2,3,4,5])
set6.remove(3) # remove删除一个不存在的元素会报错
print(set6) set6.discard(666) # discard删除一个不存在的元素不会报错,存在则删除
print(set1)
集合的方法
set1=[1,4,7,5,9,6]
set2=set([2,4,5,9,8])
# 交集
print(set1.intersection(set2))
print(set1 & set2)
print(set1.isdisjoint(set2)) # 判断两个集合是否有交集,有则返回true;没有则返回false # 并集
print(set1.union(set2))
print(set1 | set2) # 差集(补集)
print(set1.difference(set2)) #set1里有,set2里没有
print(set1-set2)
print(set2.difference(set1)) #set2里有,set1里没有
print(set2-set1) # 对称差集
print(set1.symmetric_difference(set2))#我有你没有的 加上 你有我没有的
print(set1^set2) # 子集
set3=set([4,5])
print(set3.issubset(set1)) #判断set3是否为set1的子集
print(set1.issuperset(set3)) #判断set1是否包含set3
# 遍历
set7 = set([1,2,3,4,5])
for i in set7:
print(i)
# set没有索引
# print(set7[2]) for index,i in enumerate(set7):
print(index,i)
基础数据类型的总结
数字
字符串
集合:无序,即无序存索引相关信息
元组:有序,需要存索引相关信息,不可变
列表:有序,需要存索引相关信息,可变,需要处理数据的增删改
字典:无序,需要存key与value映射的相关信息,可变,需要处理数据的增删改
按存值个数区分
标量/原子类型 | 数字,字符串 |
容器类型 | 列表,元组,字典 |
按可变不可变区分
可变 | 列表,字典 |
不可变 | 数字,字符串,元组,布尔值 |
按访问顺序区分
直接访问 | 数字 |
顺序访问(序列类型) | 字符串,列表,元组 |
key值访问(映射类型) | 字典 |
类型转换
#list > set
l1 = [1,2,3,4,5,5,3,2,5,6,9]
print(set(l1)) #tuple > set
t1 = (1,2,3,4,4,5,2)
print(set(t1)) #set > list
s1 = {1,2,3,4}
print(list(s1)) #set > tuple
s2 = {1,2,3,4,5}
print(tuple(s2))
Python--基础二的更多相关文章
- Python 基础 二
Python 基础 二 今天对昨天学习的Python基础知识进行总结,学而不思则惘,思而不学则殆! 一.先对昨天学习的三大循环的使用情况进行总结: 1.while循环的本质就是让计算机在满足某一条件的 ...
- 进击的Python【第二章】:Python基础(二)
Python基础(二) 本章内容 数据类型 数据运算 列表与元组的基本操作 字典的基本操作 字符编码与转码 模块初探 练习:购物车程序 一.数据类型 Python有五个标准的数据类型: Numbers ...
- Python基础(二) —— 字符串、列表、字典等常用操作
一.作用域 对于变量的作用域,执行声明并在内存中存在,该变量就可以在下面的代码中使用. 二.三元运算 result = 值1 if 条件 else 值2 如果条件为真:result = 值1如果条件为 ...
- python基础(二)----数据类型
Python基础第二章 二进制 字符编码 基本数据类型-数字 基本数据类型-字符串 基本数据类型-列表 基本数据类型-元组 可变.不可变数据类型和hash 基本数据类型-字典 基本数据类型-集合 二进 ...
- python基础二(基础数据类型)
一. 引子 1. 什么是数据 x=10,10是我们要存储的数据 2. 为何数据要分不同的类型 数据是用来表示状态的,不同的状态就应该用不同的类型的数据去表示 3.数据类型 数字 字符串 列表 元组 字 ...
- Python菜鸟之路:Python基础(二)
一.温故而知新 1. 变量命名方式 旧的方式: username = 'xxxx' password = 'oooo' 新的方式: username, password = 'xxxx', 'oooo ...
- python基础二(list,tuple元祖、dic字典,字符串)
一.列表list 1.list定义 列表即数组 ,list或array..列表中的每个元素都有自己的编号,从0开始,编号也可叫做下标,角标,索引.最后一个元素的下标也可用-1表示.: list定义时, ...
- Python基础二. 数据结构、控制流、运算符、真值测试
一.概述 数据结构上广义上有两种,单一类型和集合类型 单一类型,表示一种对象 集合类型,表示包含多种对象 Python 中的内建的数据类型有str.list.tuple.dict.set.number ...
- 【笔记】Python基础二:数据类型之集合,字符串格式化,函数
一,新类型:集合 集合出现之前 python_l = ['lcg','szw','zjw'] linux_l = ['lcg','szw','sb'] #循环方法求交集 python_and_linu ...
- Python之路-python基础二
本章内容: 一.编码格式 二.常用数据类型 三.字符串常用方法 四.列表常用方法 五.数据运算 六.课后作业 编码格式: ASCII A ...
随机推荐
- EF 查询视图出现重复数据
解决方案: 由多张表组成的视图,要加实体键.而且实体键组合要能确保唯一性. 个人理解:确保唯一性,一个或多个实体键,实现了复合主键或组合主键的效果. 这样查询是,延迟加载机制,才知道哪些需要重新从数据 ...
- DataTable克隆行
DataRow Adr = ds.Tables[].NewRow(); Adr.ItemArray = (].Rows[].ItemArray.Clone(); ds.Tables[].Rows.Ad ...
- JavaScript中的typeof
js中的 typeof 操作符返回一个字符串,表示未经计算的操作数的类型. 其中null.字符串对象.数字对象.布尔对象.日期.数组.正则返回结果都为object,可见typeof返回结果并不精确 测 ...
- Doctype的作用?严格模式与混合模式,如何触发者这两种模式,区分它们有何意义?
Doctype作用?严格模式与混合模式,如何触发者这两种模式,区分它们有何意义? 1.1 Doctype作用 <!DOCTYPE>声明叫做文件类型定义(DTD),声明的作用为了告诉浏览器该 ...
- rocketmq批量消息投递
批量发送消息可提高传递小消息的性能.同时也需要满足以下特征 批量消息要求必要具有同一topic.相同消息配置 不支持延时消息 建议一个批量消息最好不要超过1MB大小 示例 小于1MB String t ...
- Docker JDK镜像
Docker jdk镜像 说明 使用alpine-glibc作为基础镜像 JAVA JDK/JRE以1.8为基准 下载文件 1.下载JDK/JRE压缩包. jre-8u201-linux-x64.ta ...
- 【RL-TCPnet网络教程】第2章 嵌入式网络协议栈基础知识
第2章 嵌入式网络协议栈基础知识 本章教程为大家介绍嵌入式网络协议栈基础知识,本章先让大家有一个全面的认识,后面章节中会为大家逐一讲解用到的协议. 基础知识整理自百度百科,wiki百科等 ...
- SQLServer删除登录帐户
删除登陆账户注意事项 不能删除正在登录的登录名. 也不能删除拥有任何安全对象.服务器级对象或 SQL Server 代理作业的登录名. 可以删除数据库用户映射到的登录名,但是这会创建孤立用户. 有关详 ...
- kubernetes deployment升级和回滚
a.创建deployment pod kubectl run mynginx --image=docker.io/nginx: --record 准备svc文件 apiVersion: v1 kind ...
- 在centos中搭建基于nginx的apt源服务器,整合yum源和apt源在一台服务器
1.首先关闭防护墙或者设置规则通过且关闭selinux 2.nginx-1.14.2版本(编译安装)-自定义安装路径 3.开启nginx目录浏览 以上步骤请参考前文:https://www.cnblo ...