【笔记】Python基础一 ：变量，控制结构，运算符及数据类型之数字，字符串，列表，元组，字典

count = 0
s = 0while count < 10:
if count != 7:
print (count)
count = count + 1
print('----end----')count = 1
while count < 101:
s = count + s
count = count +1
print(s)
print('----end----')count = 1
while count < 101:
if count%2 == 1:
print(count)
else:
pass
count = count + 1print('----end----')count = 1
while count < 101:
if count%2 == 0:
print(count)
else:
pass
count = count + 1print('----end----')count = 1
s = 0
while count < 101:
if count%2 == 0:
s = s - count
else:
s = s + count
count = count + 1
print(s)
print('----end----')

#首字母大写
test = "aLex"
v = test.capitalize()
print(v)# 所有变小写，casefold更牛逼，很多未知的对相应变小写
v1 = test.casefold()
print(v1)
v2 = test.lower()
print(v2)# 设置宽度，并将内容居中
# 20 代指总长度
# * 空白未知填充，一个字符，可有可无
v = test.center(20,"中")
print(v)

# 去字符串中寻找，寻找子序列的出现次数
test = "aLexalexr"
v = test.count('ex')
print(v)test = "aLexalexr"
v = test.count('ex',5,6)
print(v)# 欠
# encode
# decode# 以什么什么结尾
# 以什么什么开始
test = "alex"
v = test.endswith('ex')
v = test.startswith('ex')
print(v)# 以expandtabs里的数字为一组，使用\t补全该组
test = "12345678\t9"
test1 = "username\temail\tpassword\nlaiying\tying@email.com\t123"
v = test.expandtabs(6)
v1 = test1.expandtabs(20)
print(v,len(v))
print(v1)# 从开始往后找，找到第一个之后，获取其位置
# > 或 >=
test = "alexalex"
# 未找到 -1
v = test.find('ex')
print(v)# index找不到，报错 忽略
test = "alexalex"
v = test.index('')
print(v)# 格式化，将一个字符串中的占位符替换为指定的值
test = 'i am {name}, age {a}'
print(test)
v = test.format(name='alex',a=19)
print(v)test = 'i am {0}, age {1}'
print(test)
v = test.format('alex',19)
print(v)# 格式化，传入的值 {"name": 'alex', "a": 19}
test = 'i am {name}, age {a}'
v1 = test.format(name='df',a=10)
v2 = test.format_map({"name": 'alex', "a": 19})# 字符串中是否只包含 字母和数字
test = ""
v = test.isalnum()
print(v)

#是否包含字母，汉字
test = "asdf2"
v = test.isalpha()
print(v)#是否是数字,isdecimal十进制-》isdigit包含特殊字符数字①-》isnumeric能识别大写的“二”
test ="①"
v1 = test.isdecimal()
v2 = test.isdigit()
v3 = test.isnumeric()
print(v1,v2,v3)# 符合标识符规则就行，不能以数字开头
test ="class"
v = test.isidentifier()
print(v)#是否存在不可显示的字符\t \n
test ="ssn\tdd"
v = test.isprintable()
print(v)#判断是否全部是空格
test =" "
v = test.isspace()
print(v)#每个词的首字母都大写，成为标题
test = "A is For Anna"
v = test.istitle()
print(v)
v2 = test.title()
print(v2)
v3 = v2.istitle()
print(v3)#*****字符串的每一个字符使用指定分隔符进行拼接
test ="你是风儿我是沙"
print(test)
t =' '
v = t.join(test)
print(v)

#判断是否全部是大小写，转换成大小写
test = "Alex"
v1 = test.islower()
v2 = test.lower()
print(v1,v2)v1 = test.isupper()
v2 = test.upper()
print(v1,v2)#去除空格及不可见字符\t \n,指定内容可以把指定内容去掉，有限最多匹配
test = "\nalex "
print(test)
v = test.lstrip()
print(v)
v = test.rstrip()
print(v)test = "xalex "
print(test)
v = test.lstrip(‘9lexex’)
print(v)# 对应替换
test = "你是风儿我是沙"
test1 = "去你妈的风河沙"
v = "你是风儿我是沙 334"
m = str.maketrans(test,test1)
new_v = v.translate(m)
print(new_v)# 如果能分割，分割成三份
test = "testasdsddfg"
v = test.partition('s')
print(v)
v = test.rpartition('s')
print(v)
# 全部分割，或者指定分割次数，但取不到分隔符
v = test.split('s',2)
print(v)
v = test.rsplit('s',2)
print(v)#只能根据换行分割，True,False用来指定保留换行符\n
test = "asdfasdf\nasdfasdf\nasdf"
v = test.splitlines(True)
print(v)#以X开头，以X结尾
test = "backend 1.1.1.1"
v = test.startswith('B')
print(v)
v = test.endswith('')
print(v)#大小写转换
test = "aLEx"
v = test.swapcase()
print(v)

# 变量名
# break
# continueindex = 0
while index < len(test):
v = test[index]
print(v)
index += 1print('=======')for zjw in test:
print(zjw)test = "郑建文妹子有种冲我来"
for item in test:
print(item)
breakfor item in test:
continue
print(item)# 二、索引，下标，获取字符串中的某一个字符
v = test[3]
print(v)# 三、切片
v = test[0:-1] # 0=< <1
print(v)# 四、获取长度
# Python3： len获取当前字符串中由几个字符组成
v = len(test)
print(v)
#计算列表里面元素个数
li = [11,22,33,44,55]
len(li)

# 注意：在其他数据类型中下面这些操作一样可以用
# len("asdf")
# for循环
# 索引
# 切片# 五、range()获取连续或不连续的数字，
# Python2中直接创建在内容中
# python3中只有for循环时，才一个一个创建
# r1 = range(10)
# r2 = range(1,10)
# r3 = range(1,10,2)
# 帮助创建连续的数字,通过设置步长来指定不连续
# v = range(0, 100, 5)
#
# for item in v:
# print(item)

# 练习题：根据用户输入的值，输出每一个字符以及当前字符所在的索引位置
test = input(">>>")
for item in test:
print(item)# 将文字 对应的索引打印出来：
test = input(">>>")
print(test) # test = qwe test[0] test[1]
l = len(test) # l = 3
print(l)r = range(0,l) # 0,3
for item in r:
print(item, test[item]) # 0 q,1 w,2 etest = input(">>>")
for item in range(0, len(test)):
print(item, test[item])

name = "zhengjianwen"
age = ""info = name + age
print(info)

#1，在切片里面，-1代表最后一个位置，因此下面输出rooted。-2代表倒数第二个位置
name = "rootedd"
print(name[1:-1])#2，只要一个对象能执行
for i in 值
print(i)
就可以称为可迭代对象#3，类，类型
str 是一个类型，bool是一个类型
a1 = “alex” a1是一个对象#4，range用法
#在python2还有一个xrange()，相当于python3里面的range，for循环的时候才一个一个创建。#从100 到0，注意步长为-1
for i in range (100,0,-1):
print(i)#5，Pycharm 有reformat代码的功能

#1,原来值后追加
li = [11,22,33,44]
v = li.append(5)
print(v)
print(li)
li.append([1234,5678])
print(li)#2，清空列表
li.clear()
print(li)#3,浅拷贝
li = [11,22,33,"","alex"]
v = li.copy()
print(v)#4，计算元素出现的次数
v = li.count("")
print(v)#5, 扩展原来的列表，参数是可迭代对象，与append区别是，append把参数当成整体添加，extend则拆解添加
li = [11,22,33,22,44]
li.extend([9898,"不得了"])
print(li)
li.extend("下雨了")
print(li)#6，根据值获取当前值索引位置（左边优先）
li = [11,22,33,22,44]
v = li.index(22,2)
print(v)#7，在指定索引位置插入
li = [11,22,33,22,44]
li.insert(0,99)
print(li)#8，删除某个值(可以指定索引，默认是最后一个),并获取删除值
li = [11,22,33,22,44]
v = li.pop(1)
print(li)
print(v)
#删除列表中的指定值，左边优先
li = [11,22,33,22,44]
li.remove(22)
print(li)
#删除方法汇总 1,pop 2,remove 3,del li[0] 4,del li[7:9] 5，clear#9，将当前列表进行反转
li = [11,22,33,22,44]
li.reverse()
print(li)#10,列表的排序
li = [11,22,33,22,44]
li.sort(reverse=True)
print(li)
#欠 cmp key sorted#字符串和列表的区别:字符串创建之后不能修改
v = "alex"
v = v.replace('l','el')
print(v)
#产生新的字符串li = [11,22,33,44]
li[0]#索引取值
li[0] = 999 #索引修改s = "alex"
print(s[0]) #索引取值
s[0] = "E" #索引不能修改
print(s)

#1，列表怎么写：中括号括起来，使用逗号分割，列表中的元素可以是数字,字符串,列表,布尔值,所有的都能放进去，
#2，可以嵌套
#列表的数学抽象就是一个"集合"li = [1,12,9,"age",["市政",["",10],"旁买了"],"alex",True]#3，索引取值
print(li[3])
#嵌套情况取值
print(li[4][1][0])#4，切片,切片结果也是列表
print(li[3:5])#5，for,while 循环
# for item in li:
# print(item)#6，索引
#索引修改
li[1] = 120
print(li)
li[4] = [11,22,33,44]
print(li)#索引删除
del li[4]
print(li)#7，切片
#切片修改
li[0:3] = [1,2,3]
print(li)#切片删除
li2 = [1,12,9,"age",["市政","旁买了"]]
del li2[2:3]
print(li2)#8，查找 in操作
li3 = [1,12,9,"age",["市政","旁买了"]]
v = "市政" in li3[4]
print(v)#9,字符串可以转列表（内部使用for循环），数字不能for循环，不能转换列表
s = "12eewdsd"
new_li = list(s)
print(new_li)
#列表转换成字符串
#如果列表里有字符串和数字的混合，只能使用for循环来转换
li = [11,22,33,"","alex"]
print(li)
r = str(li)
print(r)s = ""
for i in li:
s = s + str(i)
print(s)#如果列表里只有字符串,则可以使用join简单处理
li = ["","alex"]
v = "".join(li)
print(v)

#1,元组是对列表的二次加工，元组的一级元素不可被修改，不能被增加或者删除
#一般写元组的时候，推荐在最后加入逗号
li = [111,22,33,44]
tu =(111,22,33,44,)
#2,索引
v = tu[0]
print(v)
#3,切片
v = tu[0:2]
print(v)#tu[0] = 123 # 不能修改
#del tu[0] # 不能删除
#4,可以被for循环，可迭代对象（字符串，列表，元组都是可迭代对象）
for item in tu:
print(item)#5,转换
s = "asdfasdf0"
li = ['asdf',123]
tu = (123,123,"asdf")v = tuple(s) #字符串转元组
print(v)v1 = tuple(li)#列表转元组
print(v1)v2 = list(tu)#元组转列表
print(v2)#如果元组里面只有字符串,使用join转换
tu = ("","asdf")
v = "_".join(tu)
print(v)#可迭代对象可以使用extend
li = ["asdf","assdfasdf"]
li.extend((11,22,33,))
print(li)#6，元组也是有序的,元组里面的列表是可以修改的
tu = (111,"alex",(11,22),[(33,44)],True,33,44)
v = tu[3][0][0]
print(v)
#tu[0] = 123
tu[3][0]= 567
print(tu)

dt ={}dt.clear()
dt.copy() #浅拷贝#静态方法 直接使用类名执行方法
#@staticmethod # known case
#def fromkeys(*args, **kwargs): # real signature unknown#1，根据列表，创建字典，并指定统一值
v = dict.fromkeys(["k1",123,""],123)
print(v)#2，get取值方法
dic = {
"k1":"v1",
"k2":"v2"
}
#v = dic['k11111']
#如果键值不存在则报错
#print(v)
#使用get方法就不报错,而返回None,也可以指定返回值
v = dic.get('k111',"asdfasdf")
print(v)#3，pop方法删除并获取值 ,如果对应键没有，也可以返回设定的返回值
dic = {
"k1":"v1",
"k2":"v2"
}
v = dic.pop("k11",90)
print(v,dic)#popitem 随机删除
dic = {
"k1":"v1",
"k2":"v2"
}
v = dic.popitem()
print(v)#4，setdefault,如果键存在则不进行设置返回键的原有值；如果键不存在，则添加一个键值对
dic = {
"k1":"v1",
"k2":"v2"
}
v = dic.setdefault('k111','')
print(dic,v)#5，更新
dic = {
"k1":"v1",
"k2":"v2"
}
v = dic.update({'k1':'','k3':''}) #传值传字典
print(dic)dic.update(k1=123,k2=345,k3=456) #如果在函数中把参数名写成**，则会把参数自动转换成字典
print(dic)#字典里面最常用的是keys(),values(),items(),get(),update()

#1，字典 dict基本结构
info ={
"k1":"v1", #键值对
"k2":"v2"
}#2，字典的value可以是任何形式
info ={
"k1":18,
"k2":True,
"k3":[
11,
22,
33,
{'kk1':'vv1',
'kk2':'vv2',
'kk3':(11,22),
}
],
"k4":(11,22,33,44)
}
print(info)#3，列表和字典不能作为字典的key
#布尔值可以作为key，但要注意和0，1重复的问题
info = {
1:'asd',
"k1":'asdf',
True:"",
#[11,22]:123,
(11,22):123,
#{'11':'22'}:123,
}#4，通过打印可以知道字典是无序的#5，索引方式(key)找到指定元素
v = info["k1"]
print(v)
v = info[1]
print(v)
info ={
"k1":18,
"k2":True,
"k3":[
11,
22,
33,
{'kk1':'vv1',
'kk2':'vv2',
'kk3':(11,22),
}
],
"k4":(11,22,33,44)
}
#找到kk3里面的的11
v = info["k3"][3]["kk3"][0]
print(v)
#字典不能通过切片方式找#6，del删除
info ={
"k1":18,
"k2":True,
"k3":[
11,
22,
33,
{'kk1':'vv1',
'kk2':'vv2',
'kk3':(11,22),
}
],
"k4":(11,22,33,44)
}
print(info)
del info["k1"]
print(info)
del info["k3"][3]["kk1"]
print(info)#7，字典支持for循环
info ={
"k1":18,
"k2":True,
"k3":[
11,
22,
33,
{'kk1':'vv1',
'kk2':'vv2',
'kk3':(11,22),
}
],
"k4":(11,22,33,44)
}for item in info:
print(item)for item in info.keys():
print(item)for item in info.values():
print(item)for k,v in info.items():
print(k,v)

# 0 1
# bool(...)
# None "" () [] {} 0 ==> False