python数据类型

补充：

检查数据类型： type(数据)
num1 = 1.0
print(type(num1))
 结果：class:int 

格式化输出

age = 18
print('我的年龄%d岁'  %age)
weight = 75.6
print('我的体重%.2f' %weight)

print(f'我的年龄{age}岁')

数字逻辑运算符

/// and 所有为1，结果才为1
/// 如果有一个不是1，则取最后一个非1的数
a = 1 and  2     结果是2
a = 1 and 0     结果是0

/// or 所有是0，结果才为0
/// 如果有不是0的，则以带个非0为结果
a = 1 or 0 结果是 1
a = 0 or 2 结果是 2

判断语句

格式
if 判断条件：
空格 执行语句1
空格 执行语句2

if a==1:
    print('a 等于 0')
    print('a 等于 0')

随机数

///导入random模块
import random
/// 调用函数randint(开始，结束)
/// 是包括开始和结束的范围
b = random.randint(0,2)
/// 结果可能是0、1、2
print(b)

三目运算符

格式
条件成立执行的表达式 if 条件 else 条件不成立执行的表达式

a = 1
b = 2

c = a if a>b else b
/// 结果是 2
print(c)

for 循环

name = 'Liven'
for chart in name:
    print(chart)

else 与 循环配合使用，else 下方缩进的代码指的是当循环正常结束之后要执行的代码
break跳出循环就是非正常结束
continue跳过某次循环执行完毕，也是正常结束

while 条件：
    条件成立重复执行的代码
else:
    循环正常结束之后要执行的代码


for 临时变量 in 序列：
  重复执行代码
else:
  循环正常结束之后要执行的代码

字符串

• 下标

/// 通过下标(索引)获取某个值
name = 'Liven'
/// 结果 L
print(name[0])

• 切片

切片是指对操作的对象截取其中一部分的操作。
字符串、列表、元组都是支持切片
格式
序列[开始位置下标:结束位置下标:步长]

注意：
* 不包括结束位置下标对应的数据，正负证书均可
* 步长是选取间隔，正负整数均可，默认步长是1，可以不写

num = '0123456'
/// 结果：234
/// 步长默认是1，如果要求步长为1 ，可以不写
print(num[2:5:1])
print(num[2:5])
/// 结果：24
print(num[2:5:2])

/// 如果开始位置下标没写，那么默认就是0 
/// 结果：01234
print(num[:5])

/// 如果结束位置下标没写，那么默认是到序列的末尾
/// 结果：23456
print(num[2:])

/// 开始下标和结束下标都没写，则是获取序列全部
/// 结果：0123456
print(num[:])

/// 步长设置负数：表示倒叙选取
/// 结果：2
print(num[2:3:1])
/// 结果：3
print(num[3:2:-1])

/// 结果就是反相：6543210
print(num[::-1])

/// 下标-1表示最后一个数据，依次向前类推
/// 结果：345
print(num[-4:-1])

/// 下标取负 同时 步长也取负数
/// 结果为空
/// 分析：开始位置-4到结束位置-1，结果是345
/// 但是如果步长取负数-1，那么就是从相反的反向截取字段，但是与开始位置到结束位置的方向相反，导致截取为空
print(num[-4:-1:-1])

/// 结论：
/// 如果选取方向（下标开始位置到结束位置的反向） 和 步长的反向冲突，则无法截取数据

• 字符串常用操作方法：查找、修改、判断

#查找
字符串查找就是查找子串在字符串中的位置或出现的次数

* find() : 检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置，否则返回-1
* rfind() 跟 find()相似，只是方向不同，rfind()是从右到左开始查找
格式：
字符串.find(子串，开始位置下标，结束位置下标)
//// 注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找

* index()： 作用与语法都跟find()一样，不同的是，当在字符串中找不到对应的子串，那么find()方法是返回-1，而index()则会报异常
* rindex() 跟 find()相似，只是方向不同，index()是从右到左开始查找

* count():在字符串中查找子串的个数
格式：
字符串.count(子串，开始位置下标，结束位置下标)

num = 'hello world and itcast and itheima and Python'
/// 结果： 12
print(num.find('and'))
/// 结果： 12
print(num.index('and'))
/// 结果：3
print(num.count('and'))

# 修改
修改，指的是通过函数的形式修改字符串中的数据

* replace(): 替换
replace函数有返回值，返回值是修改后的字符串
格式：
字符串序列.replace(旧子串，新子串，替换次数)
/// 注意：替换次数，如果查出子串出现次数，则替换次数为该子串出现的次数

old_str = 'hello world and itcast and itheima and Python'
new_str = old_str.replace('and','he')
print(new_str)


* split()：按照指定字符分割字符串，返回一个列表
格式：
字符串序列.split(分割字符，num)
/// 注意：num表示的是分割字符出现的次数，即将来返回数据个数为num+1个
my_str = 'hello world and itcast and itheima and Python'
/// 结果：['hello world','itcast','itheima','Python']
print(my_str.split('and'))

* join()：合并列表里面的字符串数据为一个大字符串
格式：
字符串.join(多字符串组成的序列)
/// 结果：aa...bb...cc
mylist = ['aa','bb','cc']
new_str = '...'.join(mylist)


/// 不常用的操作方法
title() : 将字符串每个单词首字母转换成大写，其他的字符都是小写
capitalize() : 将字符串第一个字符转换成大写
lower() : 将字符串中大写转小写
upper() : 将字符串中小写转大写
lstrip() : 删除字符串左侧空白字符
rstrip(): 删除字符串右侧空白字符
strip(): 删除字符串两侧空白字符

ljust()：返回一个原字符串左对齐，并使用指定字符串（默认空格）填充至对应长度的新字符串
格式：
字符串序列.ljust(长度,填充字符)
mystr = 'hello'
/// 结果：hello,,,,,
print(mystr.ljust(10,','))

rjust():右对齐
center():中间对齐

字符串判断

* startswith() : 检查字符串是否是以指定子串开头，是则返回True，否则返回False。如果设置开始和结束位置下标，则在指定范围内检查
格式：
字符串序列.startswith(子串，开始位置，结束位置)

* endswith():检查字符串是否以指定子串结尾

* isalpha() : 如果字符串至少有一个字符并且所有字符都是字母则返回True,否则返回False

* isdigit() : 如果字符串只包含数字则返回True 否则 返回False

* isalnum(): 如果字符串至少有一个字符并且所有字符都是字母或数字则返回True，否是返回False

* isspace(): 如果字符串只包含空格，则返回True，否是返回False

列表

* index() 返回指定数据所在位置的下标
格式:
列表序列.index(数据，开始位置，结束位置)

* count() 统计指定数据在当前列表中出现的次数
格式：
列表序列.count(数据，开始位置，结束位置)

* len() 访问列表长度
格式：
len(列表序列)

* in 判断指定数据在某个列表序列是否存在，如果在就返回True，否则返回False
name_list = ['Tom','Liven','James']
/// 返回结果：True
print('Tom' in name_list)

* not in 判断指定数据不再某个列表序列，如果不在就返回True，否则返回False


* append() 列表结尾追加数据
格式：
列表序列.append(数据)

* extend() 列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表
格式：
列表序列.extend(数据)
name = ['Tom','Lily','Rose']
/// 结果：['Tom','Lily','Rose','L','i','v','e','n']
name.extend(‘Liven’)
/// 结果：['Tom','Lily','Rose', 'May','Lucy']
name.extend(['May','Lucy'])

* insert() 指定位置新增数据
格式：
列表序列.insert(位置下标，数据)

* del 删除（可是删除整个列表，也开始删除列表的某个目标）
格式：
del 目标

name = ['Tom','Lily','Rose']
/// 删除整个列表name
del name
/// 删除name列表的第一个元素
del name[0]

* pop() 删除指定下标的数据，如果不指定下标，默认删除最后一个数据（无论安装下标删除还是删除最后一个，pop函数都会返回这个被删除的数据 ）
name.pop()

* remove(数据) 
name.remove('Tom')

* clear() 清空列表
name.clear()

* 修改指定下标的数据
name[0] = 'aaa'

* reverse() 倒序
name.reverse()

* sort() 排序
格式：
列表序列.sort(key=none,reverse=True降序 False升序(默认))

numlist = [1,5,3,2,6]
/// 结果：[1,2,3,5,6]
print(numlist.sort())

* copy() 复制列表
oldlist = ['1','2']
newlist = oldlist.copy()

列表的循环

name_list = ['Tom','Lili']
a = 0
while a < len(name_list) :
  print(name_list[a])
  a += 1

for name in name_list :
  print(name)

元组
元组与列表的区别：元组内的数据是不能修改的，列表则可以
元组特点：
定义元组使用小括号，且逗号隔开各个数据，数据是可以不同类型
/// 多个数据元组
t1 = (10,20,30)
/// 单个数据元组
t2 = (10,)
/// 注意：如果定义的元组只有一个数据，那么这个数据后面也最好添加逗号，否则数据类型为唯一的这个数据的数据类型

t3 = (10,)
/// 结果：typle
print(type(t3))
t4 = (20)
/// 结果： int
print(type(t4))

元组数据不支持修改，只支持查找

• 按下标查找
• index()
• count()
• len()

字典

* 字典查找
字典序列[key]
/// 如果当前查找的key存在则返回对应的值，否则报错

* get()
格式
字典序列.get(key,默认值)
/// 注意：如果当前查找的key不存在则返回第二个参数（默认值），如果省略第二个参数，则返回None

 * keys()
格式：
字典序列.keys()

* values()
格式：
字典序列.values()

 * items()
格式：
字典序列.items()

dict1 = {'name':'Tom','age','20'}

for key in dict1.keys():
  print(key)

for value  in dict1.values():
  print(value)

for item in dict1.items():
/// item是元组
  print(item)

for key,value in dict1.items()：
  print(f'{key} = {value}')

集合

集合的特点：去重、无序（不支持下标操作）

创建集合使用{}或set(),但是如果要创建空集合只能使用set(),因为{}
用来创建字典

* add() 增加数据
s1 = {20,30}
s1.add(100)
/// 因为集合有去重的功能，所以，当向集合追加的数据是当前集合已有数据的话，则不进行任何的操作

* update() 增加的数据是序列
s1.update([100,200])

* remove() 删除集合中指定的数据，如果数据不存在则报错

* discard() 删除集合号中指定的数据，如果数据不存在也不会报错

* pop() 随机删除集合中的某个数据，并返回这个数据

公共操作

image.png

数据类型转换

* tuple() 转换成元组


* list() 转换成列表


* set() 转换成集合

推导式

* 列表推导式
  �作用：用一个表达式创建一个有规律的列表或控制一个有规律列表

  例子：创建0~10的偶数列表
方法 一：
 list1 = [i for i in range(0,10,2)]
print(list)
方式二：
list1 = [i for i in range(10) if i % 2 ==0]

多个for循环实现列表推导式
例子：创建如下列表
[(1,0),(1,1,),(1,2),(2,0),(2,1),(2,2)]

list1= [(i,j) for i range(1,3)  for j in range(3)]


* 字典推导式
作用：快速合并列表为字典或提取字典中目标数据

例子：创建一个字典，字典key是1-5数字，value是这个数字的2次方
dict1 = {i:i**2 for i in range(1,6)}

例子：将两个列表合并成一个字典
list 1 = ['name','age','gender']
list2 = ['Tom',10,'man']

dict1 = {list[i] : list[2] for i in range(len(list1))}

例子：提取字典中目标数据
提去上述电脑数量大于等于200的字典数据
counts = {'MBP':268,'HP':125,'DELL':201,'Lenovo':199}

counts1 = { key:value for key,value in counts.items() if value >= 200}


* 集合推导式