python基础二

基础数据类型 总览
int：用于计算，计数，运算等。1，2，3，4
str：“这些内容” 用户少量数据的存储，便于操作。
bool：True，False，两种状态，机器反馈给用户的对，错。
list： [1,"alex",True,{},[],()...] 大量的数据，各种数据类型，操作方便。
tuple：（1,"alex",True,{},[],()...），只读列表。
dict：字典。存储大量关联性的数据。
{“name”：“alex”，“name_list”:[luffy,zoro,...],"太白"：{“name”：“太白”，“sex”：“男”}}
set：集合。{}关系测试。交集，差集，并集，子集..

第一部分 ：索引切片步长

按照索引值，取出来的都是一个字符，形成的字符串

s1 = "python深圳1期骑士计划"

print(s1[0])
print(s1[-1])

#按切片取值.遵循原则。顾首不顾尾
print(s1[0:3])
print(s1[:3])
print(s1[0:])
print(s1[6:-1])
print(s1[6:])
print(s1[:-1])
print(s1[:])

#按照切片+步长
print(s1[:5:2])
print(s1[::2])
print(s1[::-2])
print(s1[::-1])

#如果要倒着取值，要加一个反向步长
print(s1[:-6:-2])

第二部分：字符串常用方法

name = "olDBoy"

#capitalize() 首字母大写 ***
print(name.capitalize())

#center 字符串居中，前后填充自定义的字符 **
print(name.center(20,"*"))

#upper：全部大写  lower：全部小写 *****
print(name.upper())
print(name.lower())
#应用举例
# code = "ADfer".upper()
# your_code = input("请输入验证码：").upper()
# if your_code == code :
#     print("验证码正确")

#startswith  ,endswith 判断开头结尾 ****
# print(name.startswith("ol"))
# print(name.endswith("o"))
# print(name.endswith("B",3))   #判断位置3是否3开头
print(name.startswith("lD",1,5))


#swapcase 大小写翻转  **
print(name.swapcase())


s1 = "alex wusir*taibai6nvshen"

#title ：非字母隔开的每个部分的首字母大写 **
print(s1.title())

#find  通过元素找索引，找到第一个就返回，没有此元素就返回-1  *****
#index :通过元素找索引，找到第一个就返回，没有此元素就报错  *****

print(name.find("B"))
print(name.find("lD"))
print(name.find("w"))
print(name.find("D",1,-1))

print(name.index("D"))

print("----------------")
name = "    oldboy	
"
print(name)
#strip ：默认去除字符串前后的空格，换行符，制表符   *****
print(name.strip())
name1 = "wer*alexweq**"
print(name1.strip("erw"))  #指定字符，从两端开始去除字符，直到遇到其他字符停止
#应用：
# name = input("请输入用户名：").strip()
# if username == "alex":
#     print("登陆成功..")
#lstrip :去除左边的制表符换行符空格   rstrip:右边


s1 = "alex wusir taibai"
#split：将字符串分割成列表（str ---->list） *****
l1 = s1.split() #默认按照空格分隔
print(l1)
s2 = "alex,wusir,taibai"
print(s2.split(","))

s3 = ",alex,wusir,taibai "
print(s3.split(","))
s4 = " alex wusir taibai"
print(s4.split(" ")) #空格

s5 = "alexlwle"
print(s5.split("l",1))   #设置分割次数
#课下练习：
print(s5.rsplit())


str1 = "alex"
#join :自定制连接符，将可迭代对象中的元素连接起来（list ---->str）*****
s2 = "*".join(str1)
print(s2)

str2 = "alex 是创始人，alex很nb，alex...."
#replace *****
s3 = str2.replace("alex","SB")
print(s3)
s3 = str2.replace("alex","SB",1)  #替换次数
print(s3)



#格式化输出：format
s1 = "我叫{}，今年{}，性别{}"
#三种方式
#第一种
s2 = "我叫{}，今年{}，性别{}".format("taibai","28","nnan")
print(s2)
#第二种
s3 = "我叫{0}，今年{1}，性别{2}，我依然叫{0}".format("taibai","28","nnan")
print(s3)
#第三种
s4 = "我叫{name}，今年{age}，性别{sex}，我依然叫{name}".format(age="28",name="taibai",sex="nnan")
print(s4)

#is系列
name = "taibai123"
print(name.isalnum()) #数字或字母组成
print(name.isdigit()) #判断是否全部数字组成
print(name.isalpha())  #判断是否全部字母组成


#公共方法
name = "alex"
print(name.count("a")) #有切片
print(len(name))

　　

for循环：对于一个数据类型进行循环，或者是一个有限次数的时候，往往要用到for

s1 = "sjdgsdj"
i = 0
while i < len(s1):
    print(s1[i])
    i += 1

for i in s1:  #for 变量 in iterable（可迭代对象：多个元素组成的数据）
    print(i)

for i in s1:  #for循环的次数是和可迭代对象的元素个数有关
    print(66)

　　

列表：python的基础数据类型之一

　　列表可以索引，切片，加步长

　　列表可以存储大量数据

# 列表：python基础数据类型之一：其他语言中也有列表的概念，。js：数组
# 可以索引，切片，加步长
# 列表可以存储大量数据

li = ["alex", 100, True, [1, 2, 3], {"name": "太白"}, (22, 23)]

# 第一：索引，切片，切片+步长
print(li[0], type(li[0]))
print(li[0:4])
print(li[-1:2:-2])

# 第二：增删改查，其他方法
l1 = ["alex", "wusir", "taibai", "egon", "景女神", "文周老师"]
# 增
# append  在列表末尾追加
l1.append("小温老师")
print(l1)
l1.append([1, 2, 3])
print(l1)
name_list = ["张三", "李四"]
# while 1:
#     username = input("请输入新员工名字：").strip()
#     if username.upper() == "Q": break
#     name_list.append(username)
# print(name_list)

# insert  插入指定位置
l1 = ["alex", "wusir", "taibai", "egon", "景女神", "文周老师"]
l1.insert(1, "宝元")
print(l1)

# extend 迭代着追加
# 拆分组成的最小元素添加到列表中
l1.extend("abc")
print(l1)
l1.extend(["alex", "sb"])
print(l1)

# 删除
# pop 按照索引去删除  增删改查里面唯一一个有返回值的
l1 = ["alex", "wusir", "taibai", "egon", "景女神", "文周老师"]
ret = l1.pop(0)
print(ret)
print(l1)

# remove 按照元素删除
l1 = ["alex", "wusir", "taibai", "egon", "景女神", "文周老师"]
l1.remove("alex")
print(l1)

# clear 清空列表
l1.clear()
print(l1)

# del
l1 = ["alex", "wusir", "taibai", "egon", "景女神", "文周老师"]
# 可以按照索引删除
del l1[0]
print(l1)
# 可以按照切片删除（可以加步长）
del l1[:1]
del l1[1::2]
print(l1)
# 可以在内存级别删除整个列表
# del l1  内存级别删除

# 改
# 按照索引改
l1 = ["alex", "wusir", "taibai", "egon", "景女神", "文周老师"]
l1[2] = "男神"
print(l1)
# 按照切片 把切片内容全清空，在把添加内容迭代着添加进去
l1 = ["alex", "wusir", "taibai", "egon", "景女神", "文周老师"]
l1[:2] = "abab"
print(l1)
l1 = ["alex", "wusir", "taibai", "egon", "景女神", "文周老师"]
l1[:4] = [11, 22, 33, 44, 55]
print(l1)
# 按照切片（加步长） ：必须一一对应
l1 = ["alex", "wusir", "taibai", "egon", "景女神", "文周老师"]
l1[:3:2] = "af"
print(l1)

# 查
# 索引，切片，切片+步长
# for循环
for i in l1:
    print(i)
# 其他方法
# print(len(l1))  查询总个数
# print(l1.count("alex"))  #某个元素出现的个数
# index 通过元素找索引    print(l1.index("taibai"))

# sort 从小到大排序
l2 = [5, 4, 6, 3, 7]
l2.sort()
print(l2)

#  从大到小排序
l2.sort(reverse=True)
print(l2)

# reverse 翻转
l2.reverse()
print(l2)

# 第三： 列表的嵌套
l3 = ['alex', 'wusir', ['taibai', 99, 'ritian'], 20]
# 1， 找到alex的e元素。
print(l3[0][2])
# 2， 将wusir变成大写。
l3[1] = l3[1].upper()
print(l3)
# 3， 给此列表['taibai',99,'ritian'] 追加一个元素,'文周'
l3[2].append("文周")
print(l3)
# 4，将 'taibai' 首字母大写
l3[2][0] = l3[2][0].capitalize()
print(l3)
# 5，将 99 通过数字加1 的方式变成100，并放回原处。
l3[2][1] += 1
print(l3)

　　

元组：只读列表，只允许查询，不允许增删改

# 元组：只读列表，只允许查询，不允许增删改
tul = ("alex", 100, True, [1, 2, 3], {"name": "太白"}, (22, 23))
# 索引， 切片， 切片+步长
print(tul[0])
print(tul[:3])
# for 循环
for i in tul:
    print(i)
# index, count
# 应用场景：一些非常重要的数据，不允许所有人修改的，放在元组中。
tul = ("alex", 100, True, [1, 2, 3], {"name": "太白"}, (22, 23))
# 元组 儿子不能改，孙子可能可以改
# "alex" , "100" 不能改   。[1, 2, 3] 里面的元素允许修改

　　

range： 自定制的，数据范围的可迭代对象，类比成列表

# range 自定制的，数字范围的可迭代对象，类比成列表。
range(1, 101)
#range 一般和for循环结合使用
for i in range(1, 20, 2):
    print(i)

for i in range(1, 101, 2):
    print(i)

for i in range(10, 1, -1):
    print(i)

l1 = ["alex", "wusir", "taibai", "egon", "景女神", "文周老师"]
for i in range(len(l1)):
    print(l1[i], i)

for i in l1:
    print(l1.index(i), i)

　　

字典：python的基础数据类型之一；字典可以存储大量的数据，关系型数据。
同时字典也是python中唯一的映射类的数据类型.
数据类型的分类：
可变的（不可哈希）数据类型：list，dict
不可变的（可哈希的）数据类型：str，int，bool

dic = {"name":"jin","age":18,"sex":"male"}
键值对的形式存在的， 键：值
字典的键必须是不可变的数据类型。（工作当中：都是由数字，或者str组成）
字典的值是任意数据类型。

优点：
字典可以存储大量的数据，关系型数据。
查询速度快。
python3.5之前包括3.5版本，字典是无序的。
python3.6开始，是有序的。

字典没有索引，切片。从增删改查开始

dic = {"name": "太白", "age": 18}
# 增
# 第一种：有此key就改，无此key就添加。
dic["sex"] = "男"
dic["age"] = 1000

# 第二种：
# setdefault  有此key则不做任何操作但是返回对应的值，无此key则添加
dic.setdefault("hobby", "讲课")
dic.setdefault("name", "alex")
dic.setdefault("sex")


# 删
# pop 通过键去删除键值对,也有返回值。
# 如果没有此键，并且设置了第二个参数，则不会报错。并且返回第二个参数。
dic.pop("name1", None)
print(dic.pop("name1", None))  #返回None
print(dic.pop("name1", "没有此键.."))  #返回”没有此键.."
print(dic.pop("name"))

# clear 清空
dic.clear()

dic = {"name": "太白", "age": 18, "sex": "男"}
# popitem： 3.5及以前随机删除某个键值对。
#           3.6以后，删除最后一组键值对。
#           有返回值
print(dic.popitem())

# del
# 按照键删除键值
# 删除整个字典
del dic["name"]
del dic

# 改
# 第一种：
dic = {"name": "太白", "age": 18, "sex": "男"}
dic["age"] = 25

# 第二种
# 两个字典，update
dic = {"name": "太白", "age": 18, "sex": "男"}
dic2 = {"hobby": "讲课"}
dic.update(dic2)  # 将dic2 中所有的键值对覆盖并添加到dic中，dic2不变
print(dic)
print(dic2)

dic.update(a="666", b=222, name="taibai")


# 查
# 通过键去获取对应的值，没有此键报错
print(dic["name"])

# get ：通过键去获取值，不存在的话返回设定值
print(dic.get("name"))
print(dic.get("name1"))
print(dic.get("name1","没有此键..."))

# dic.keys()
print(dic.keys())   # 类似于列表的容器中，没有索引，但是可以遍历。
for key in dic.keys():
    print(key)

for i in dic:  # 直接循环打印的也是key
    print(i)

# 转换成列表
list1 = list(dic.keys())  # 可以遍历。


# dic.valus()
print(dic.values())   # 类似列表的容器
list2 = list(dic.values())  # 可以遍历


# dic.items()  #可转化成列表，可遍历
print(dic.items())

# 分别赋值  必须一一对应

# 面试题
a = 10
b = 20
a, b = b, a  # 先算等号右边
print(a, b)

# len
print(len(dic))