1.python基础数据类型

基础数据类型bool

# 各种数据类型转化成bool

print(bool(0))  # False

print(bool(1))  # True

print(bool(-1))  # True

print(bool(""))  # False

print(bool(" "))  # True

print(bool("ss"))  # True

print(bool([]))   # False

print(bool([1,2]))    # True

print(bool({}))  # False

结论: 所有表示空的东西都是False

基本数据类型之间的转化, 想变成谁, 就用谁把数据括起来

 

基础数据类型str

把字符连成串. 在python中用', ", ''', """引起来的内容被称为字符串.

字符串: 把多个字符连成串

字符串是不可变的对象, 所以任何操作对原字符串是不会有任何影响的

索引.

索引就是下标, 切记, 下标从0开始

 

切片

    基本语法: str[start: end]

    规则: 顾头不顾尾, 从start开始截取. 截取到end位置. 但不包括end

s2 = "python"

print(s2[0:3])  # 从0获取到3. 不包含3. 结果: pyt

print(s2[:])    # 原样输出

print(s2[4:])   # 如果想获取到最后. 那么最后一个值可以不给.

切片完整语法:

       str[start:end:step]

    start: 起始位置

    end: 结束位置

    step: 步长

切记, 字符串是不可变对象. 所有操作都是产生新字符串返回

 

字符串操作

#大小写

s1 = "python"

ret = s1.lower() # 全部转换成小写

ret = s1.upper() # 全部转换成大写

ret = s1.strip("on") # 删除on

ret = s1.replace('python', 'on')  # 把python替换成on

# 字符串切割

s9 = "a_b_c"

lst = s9.split("_") # 字符串切割, 根据_进行切割

print(lst) #abc

lst = ['a', 'b', 'c']

s = "_".join(lst)

print(s)  # a_b_c

#查找

s13 = "我叫sylar, 我喜欢python, java, c等编程语言."

ret2 = s13.startswith("我叫sylar") # 判断是否以我叫sylar开头

print(ret2) #True

ret3 = s13.endswith("编程") # 是否以'语言'结尾

print(ret3) #False

ret7 = s13.count("a") # 查找"a"出现的次数

print(ret7)

ret5 = s13.find("sylar") # 查找'sylar'出现的位置

print(ret5)

ret6 = s13.find("tory") # 查找'tory'的位置, 如果没有返回-1

print(ret6)

ret7 = s13.find("a", 8, 22) # 切片找

print(ret7)

ret8 = s13.index("sylar") # 求索引位置. 注意. 如果找不到索引. 程序会报错

print(ret8)

# 条件判断

s14 = "123.45"

s15 = "abc"

s16 = "_abc!@"

print(s14.isdigit())# 是否由数字组成

print(s15.isdecimal())# 是否由数字组成, 不包括小数点

print(s16.isnumeric())

 

# 计算字符串的长度

s14 = "123.16"

ret = len(s14)

print(ret)

结论:

字符串索引和切片

索引从0开始

切片:

s[start: end: step]

start: 起始位置

end: 结束位置, 取不到

step: 步长.

1. upper(), 把字符串中所有的字母都变成大写. 主要使用在忽略大小写的时候用

2. strip(), 默认去掉左右两端的空白, 包括\n, \t, 空格.

3. replace(), 字符串替换

4. split(), 字符串切割. 得到字符串列表

5. join(), 把列表重新组合成字符串

6. startswith(), 判断是否以xxxx开头

7. find(), 查找xxxx

8. count(), 数数, 查看xxx出现的次数

9. isdigit(), 判断该字符串是否是由数字组成

10. len(), 字符串长度, 它是一个内置函数, 直接len(数据)即可

for 变量 in 可迭代对象:

循环体

 

基础数据类型list列表[]

增加, 注意, list和str是不一样的. list可以发生改变. 所以直接就在原来的对象上进行了操作

lst = ["a", "b", "c", "d"]

lst.append("w")

print(lst)

lst.insert(1, "ss")

print(lst)

# 迭代添加

lst = ["1", "2", "3"]

lst.extend(["4", "5"])

print(lst)

删除  pop, remove, clear, del

lst = ["a", "b", "c", "d"]

dele = lst.pop()# 删除最后一个

print("被删除的",dele)

print(lst)

lst = ["a", "b", "c", "d"]

dele = lst.pop(1)# 删除1号元素

print("被删除的",dele)

print(lst)

lst = ["a", "b", "c", "d"]

lst.remove("a")# 删除指定元素

print(lst)

lst = ["a", "b", "c", "d"]

lst.clear() # 清空list

print(lst)

lst = ["a", "b", "c", "d"] #切片删除

del lst[1:4]

print(lst)

修改

lst = ["a", "b", "c", "d"]

lst[1] ="c"

print(lst)

lst = ["a", "b", "c", "d"]

lst[1:4:2] = ["aa","bb"]

print(lst)

lst = ["a", "b", "c", "d"]

lst[0:4] = ["aa"]

print(lst)

查询

for el in lst: #列表遍历

     print(el)

其他操作

lst = ["a", "a", "c", "d"]

ret1 = lst.count("a") # 查询a出现的次数

print(ret1)

lst=[1,4,2,3]

lst.sort()#升序

print(lst)

lst.reverse()#降序

print(lst)

ret = len(lst)#列表长度

print(ret)

列表嵌套

lst = [1, 2, 3, [4, [5], 6], 7]

print(lst[3])

print(lst[3][1])

print(lst[3][1][0])

range

for num in range(10):

    print(num)

for num in range(1,10,2):

    print(num)

for num in range(10, 1, -2): # 反着来, 和切片一样

    print(num)

lst = ["a", "a", "c", "d"]

for i in range(len(lst)):

    print(i,lst[i])

基础数据类型tuple元组（）

元组: 俗称不可变的列表.又被成为只读列表, 元组也是python的基本数据类型之一,

用小括号括起来, 里面可以放任何数据类型的数据,  查询可以. 循环也可以. 切片也可以.

但就是不能改. 

tu = (1, 2, [3], 4, 5)

# tu[0]=2 不能像列表这样直接改

print(tu)

这里元组的不可变的意思是子元素不可变. 而子元素内部的子元素是可以变, 这取决于子元素是否是可变对象. 

元组中如果只有一个元素. 一定要添加一个逗号, 否则就不是元组

tu = (1,) print(type(tu))

基础数据类型dict字典{}

字典(dict)是python中唯一的一个映射类型.他是以{ }括起来的键值对组成. 在dict中key是唯一的. 在保存的时候, 根据key来计算出一个内存地址. 然后将

key:value保存在这个地址中. 这种算法被称为hash算法, 所以, 切记, 在dict中存储的key:value中的key'必须是可hash的

可哈希就意味着不可变. 这个是为了能准确的计算内存地址而规定的. 

已知的可哈希(不可变)的数据类型: int, str, tuple, bool

不可哈希(可变)的数据类型: list, dict, set

dic = {123: 456, True: 1, "id": 1, "name": 'sr', "age": 18, "stu": [2], (1, 2, 3): 'sun'}

print(dic[123])

print(dic[True])

print(dic['id'])

print(dic['stu'])

print(dic[(1, 2, 3)])

# 不合法

# dic = {[1, 2, 3]: '2'}   # list是可变的. 不能作为key

# dic = {{1: 2}: "2"}     # dict是可变的. 不能作为key

#dic = {{1, 2, 3}: '2'}  # set是可变的, 不能作为key

字典增删改查和其他操作

增加

# 如果dict中没有出现这个key, 就会新增一个key-value的组合进dict

dic={}

dic["name"] = "ww"

dic["age"] = 18

print(dic)

# 如果dict中没有出现过这个key-value. 可以通过setdefault设置默认值

dic.setdefault('22') # 也可以往里面设置值.

print(dic)

删除

ret=dic.pop("name")

print(ret)

print(dic)

del dic["age"]

print(dic)

# 清空字典中的所有内容

dic.clear()

print(dic)

修改

#把dic1中的内容更新到dic中. 如果key重名. 则修改替换. 如果不存在key, 则新增.

dic = {"id": 123, "name": 'sr', "age": 18}

dic1 = {"id": 456, "name": 'sss', "age": 11}

dic.update(dic1)

print(dic)

查询

dic = {"id": 123, "name": 'sylar', "age": 18}

print(dic['name'])

print(dic.get("ok"))

print(dic.get("sylar"))

#遍历字典

dic = {"id": 123, "name": 'sylar', "age": 18}

for k in dic:

    print(k)

#遍历字典成员

print(dic.values())

for value in dic.values():

    print(value)

#解构    

print(dic.items())

for val,k in dic.items():

    print(val,k)

字典的嵌套

# 字典的嵌套

dic1 = {

 "name": "牢大",

 "age": 18,

 "wife": {

 "name": '直升机',

 "age": 28

 },

 "children": ['see', 'you'],

}

print(dic1.get("name"))

print(dic1.get("wife").get("name"))

print(dic1.get("age"))

print(dic1.get("children")[1])

基础数据类型set

set集合是python的一个基本数据类型. 一般不是很常用. set中的元素是不重复的.无序的.里面的元素必须是可hash的(int, str, tuple,bool), 我们可以这样来记. set就是dict类型的数据但是不保存value, 只保存key. set也用{}表示

s = {"123","123","111"}

print(s)

结果：

{'111', '123'}

去重复, 交,并,差

s1 = {"wo","2","ta"}

s2 = {"1","2","3"}

# 交集

# 两个集合中的共有元素

print(s1 & s2)

print(s1.intersection(s2))

# 并集

print(s1 | s2)

print(s1.union(s2))

# 差集

print(s1 - s2)

print(s1.difference(s2))