变量 与int str bool数据类型
变量
定义：实际上变量的定义在不同的语言，不同的作者定义也是不一样的。例如：用于计算的中间值，或者指向内存中的某个具体的值,或者变量实际上是一个字符串的符号，用来关联一个存储在内存中的对象。按照自己的理解给他一个简洁的定义，内存中具体值的抽象表示。将值的操作权限给了变量，变量保存着值的引用
变量命名的规则
- 只能由数字，字母，下划线组成
- 不能以数字开头，尽量不以下划线开头（带下划线的标识符在python中有特殊的意义）
- 尽量命名见名知意，不以拼音命名
- 推荐使用单词内下划线链接的方式，驼峰命名法也可以
- 不能使用python内置的名字（函数/模块等）
name = 'li_yao'
age = 18
user_name = ''
pass_word =''
name, age, len = 'liy_ao', 18, 20 # 多变量同时定义
# 注意 变量一定先定义后使用常量
python中没有常量的概念，不过约定以全大些的形式表示常量
IP = '192,0.0.1'
PI = 3.14整型int
目前的趋势时向
int类型靠近，尤其是在python3中只有整型的概念，如基本的数字类型
int类型的运算符
+ - * / // ** % 通常我们在运算符的左右两侧各留一个空格，这样清晰美观
+= -= *= /= //= ** %= 通常我们叫做增量赋值运算符，主要用于整型
num = 0
print(1 + 2)
print(20 - 6)
print(4 * 6)
print(5 / 3) # 注意这里是真除法，不会保留小数位数
print(5 // 3) # 这里是floor除法，会进行向下取整数
print(2 ** 3) # 乘方运算，或者称为幂
print(10 % 2) # 通常用于取余数，判断奇偶，重复回溯字符串或者列表
print(num += 2) # 通常用于循环的情况比较多int类型的方法
# int 对象的方法 一个数字转化成二进制最少的位数
print(int.bit_length(10))
# python内置方法 int()
# 将严格符合数字的字符串转换成数字，通常在用户input密码输入用到
print(int('123'))
# 基于上面的情况，在将该十进制数字转换成十六进制
print(int('123', base=16))bool类型
在python中bool类型的值就两种：True False
通常情况下，bool值用于判断
出现bool值的情况
显式：我们自己给定bool值
True与False用于条件判断 或者 使用bool()内置函数来强制进行转换# 死循环也是常用到的一种循环 while True: pass # bool() print(bool('')) print(bool(1)) print(bool([1,2,3]))隐式：通常有
if判断，逻辑运算，比较运算会得出布尔值，或者某些特殊函数，比如带is的函数# if + 比较 num = 10 if num > 5 and num < 19: pass else: pass # if + 值 user_name = 'li_yao' if user_name: pass # and or not name_list = [] if not name_list: pass
转换成bool值为真为假的情况
一般我们只要知道转换成为假的情况即可：通常我们把某些值用于if的隐式转换
False 0 '' [] () {} None
# 一般我们先判断是否为空在取和数据库对比
pass_word = int(input('亲输入你的密码：'))
if pass_word:
passstr字符串类型
Python的字符串是一个有序的字符集合，由引号包围，有序指的是可以通过偏移或者索引 来访问每个字符，每个字符有严格的从左到右的位置顺序，类似于数组。
Python中没有单个字符的类型（C语言中的char），取而代之的是使用一个字符的字符串。字符串是不可变序列,不可以在原处修改，也就是无法执行类似str[0] = 'x'的操作，而执行合并,修改字符串（及分片等字符串操作都是 生成新的字符串对象。
作用：用来存储少量的数据； 特点：序列类型，可迭代对象
原始字符串
在字符串前面加r 标记为原始字符串，忽视转义符号所有字符串都是按照字面意思，没有转义与不能打印字符串
name = r'liyao_\b_good'字符串的常用方法
- 内置str()类型转换 len()获取字符串长度 []索引访问取值
name = 'faker'
# str类型转换
print(str(123))
# len()取得字符串的长度
print(len(name))
# 方括号语法访问, 下标从0开始
print(name[0])切片获取子字符串 [start_index, end_index, step] 注意切片都是左闭右开
常规切片 [start_index, end_index] 默认步长为1
# 正向 str_test = 'abcdefghijk' print(str_test[0:3]) # 反向 最后一个字符是-1 print(str_test[-3:-1])非常规切片 [start_index, end_index, step] step 可以是 + 可以 是 -
s = 'password' s1 = s[0:6:2] # 不写代表最前或者最后 s2 = s[3::2] s2 = s[::-1] s2 = s[::-2] s2 = s[0:-1] s2 = s[:] s2 = s[0:] s2 = s[-1]大小写的转换方法
大小写转换类：
.capitalize() 将首字母转换为大写
.lower() 转换为小写
.upper() 转换为大写
.swapcase() 大小写转换大小写判断类：
.islower()
isupper()print('Name'.capitalize()) print('name'.upper())计数
str_test = 'Bob I love you' print(str_test.count('o'), start_index=None, end_index=None)判断方法, 都是返回布尔值
大小写判断类：
.islower()
.isupper() .isalnum() 检测是否由数字或者字母组成，返回布尔值
.isalpha() 是否由字母组成
.isdecimal() 检测是否是常规数字
.isdigit() 检测是否的数字 可以为常规数字 或 ①等
.isnumeric() 检测是否是数字 可以为常规数字 或 ① 或 一 等填充方法
填充：固定字符串长度，然后由指定字符串填充
.center(width, str=None) 左右以width/2，str为填充字符串(str=None),str只能是一个字符
.ljust(width,str=None) 右填充
.rjust(width,str=None) 左填充
.zfill() 默认以0填充# 注意 width一定要固定总的字符串长度，所以是一定大于原字符串长度的 str_test = "good boy" # 填充满足长度 print(str_test.center(10, "-"))去除空格与指定字符
处理空格 \t \n 或者传参数移除指定的参数
.strip()
表示只是去除左边还是右边的\t \n或者参数字符
.lstrip()
.rstrip()str_test = ' name' str_test = '****good***' print(str_test.strip()) print(str_test.strip('*'))对应关系替换与替换
对应关系替换，是str对象的方法，先通过函数确定替换的关系
m = str.maketrans(str1,str2)
m = str.maketrans("od","gg")
test.translate(m).replace(sub_str, new_str, n) n代表如果有多个的话可以指定替换的个数可以通过.count(sub_str) 确定一共有多少个，而不至于超出
str_test = 'good boy' print(str_test.replace("boy", "girl"))切割字符串
切割字符串, 返回的是一个列表
.partition()
.rpartition()
.split()
.rsplit()
.splitlines()str_info = "li_yao,ai_ke,jack" # 以某个字符串来切割 print(str_info.split(','))格式化输出
.format() %
# str_test.format() 格式化输出 # 按照位置顺序格式化 '{},{},{}'.format('a','b','c') # 按照位置顺序格式化 '{0},{1},{2},{0}'.format('a','b','c') # 按照key格式化 '，后面具体的值可以使用变量代替 {name},{age},{length}'.format(age=18, name='bob, length=22') # 百分号格式化输出 name = "li_yao" age = 24 print('我的名字是%s，我的年龄是%d' %(name, age))# 模版字符串输出 python3.6添加
name = 'li_yao'
age = 24
s = f'my name is {name}, age is {age}'以特定字符串拼接
str_sub.join(str_test) 以特定字符串链接
# 注意是拼接的字符串来调用 str_sub = "*-*" str_test = "good boy" print(str_sub.join(str_test))查找
.find(sub_str, start=None, end=None) 从指定位置开始找sub_str找到第一个返回index,否则返回-1
.index(sub_str, start=None, end=None) 从指定位置开始找sub_str找到第一个返回index找不到就报错# find 通常使用这个，不会引起错误 str_test = 'he is a good boy' print(str_test.find('good')) print(str_test.index('good'))判断是否以某个字符串开头或者结尾, 返回布尔值
.startswith(suffix, start=None, end=None)
.endswith(suffix, start=None, end=None)str_test = 'he is a good boy' print(str_test.startswith('he')) print(str_test.endswith('boy'))
列表/元组/字典/集合
列表
有方括号构成 [ ] 里面的元素可以是python的任何数据类型，支持列表的嵌套
作用：可以存储大量的数据 , 读取速度慢，以空间换时间。
特点：序列类型，可迭代对象
- 查找和插入的时间随着元素的增加而增加；
- 占用空间小，浪费内存很少
在内存中通过链表的方式存储（不连续）
对列表的任何函数操作都是操作原列表，不会生成新的列表。例外sorted()--详细见内置函数.
[:]切片是对列表的浅复制，也就是说如果切片获取到了列表中的元素（成员）如果是引用类型的，那么需要注意。
# 创建列表，逗号后面有一个空格
list_test = [1, 2, 3, [False, True, 'name'], '123']访问列表中的元素
a.通过方括号索引访问里面的元素，下标从0开始
b.通过方括号切片访问里面的元素 ==> 返回的是列表类型, 同时必须要注意
c.切片取值左闭右开，和字符串切片的方式是一致的
[0:3:1][left:right:step] 正向步长
[3::-1][left:right:step] 反向步长 没有写位置代表到该方向的最后
[::-1] 列表反转
[:] 浅复制列表
d.len()得到元素的个数
e.可以使用for循环list_test = [1, 2, 3, [False, True, 'name'], '123'] # 索引访问 print(list_test[3]) # 切片访问 print(list_test[1:4]) print(list_test[0::2])列表的操作方法
删除
del l[0] l[1] l[0:2]
.pop(index=None) 删除指定位置的元素 ，不写参数默认是删除最后一个，并且返回该值
.remove(value) 删除指定值的元素
.clear() 清空list_test = [1, 2, 3, [False, True, 'name'], '123'] # del del list_test[0] # pop 返回被删除的项 print(list_test.pop(0)) #remove 没有返回值 print(list_test.remove('123')) # clear print(list_test.clear())添加
.append(value) 往后面追加一个元素（可以是任何的数据类型，但是必须是一个参数,而且“简单粗暴”的直接放进去）
.insert(index=None, value) 在指定位置添加一个元素
.extend(iterable) 遍历后面可迭代对象，然后逐一追加到后面，也必须是一个可迭代对象new_list = [1, 2, 3] # append print(new_list.append(4)) # insert print(new_list.insert(1, 'name')) # extend print(new_list.extend([5,6,7]))内置函数
list()将可迭代对象转换为列表
print(list('name'))其他方法
.index(value, start=None, end=None) 获取某个特定的元素的index
.copy() 浅复制
.count(value) 获取某个特定元素出现的次数
.reverse() 反转列表
.sort() 从小到大排序 （针对列表中是一般是数字类型，字符串类型也可以没什么意义）
.sort(reverse=True) 从大到小
元组
元组（tuple）是一个位置有序的对象的集合，支持嵌套，元素通过偏移来访问，支持基于偏移的操作，如切片和索引，与列表非常相似，但是不支持在原处修改，是不可变的,元组的不可变性只适用于元组本身顶层成员而非其内成员的内容，如元组内部的列表是可以像往常那样修改的,元组不提供字符串、列表和字典中的方法，例如想对元组进行排序，通常先将它转换成列表有序列表
元组元素的内存地址是不可改变的,所以安全性较高些，通常我们别人为了数据的安全，传递给我们的数据类型为元组
为了不与函数形式相混淆，我们通常在最后一位元素后面也加上逗号,也避免单个元素的元组的分组现象，元组可以用加号加上一个元祖来更新自己
# 创建元组 逗号后面有一个空格
tup = (1, 2, 3, 'name', 'age', 'length',)元祖出现在哪里？
一般所有的多对象的，逗号分隔的/没有明确符号定义的，都默认是元组
一般，函数返回的多对象就是元组
还有就是显示定义的元组
总结：我们总是用括号显示的定义,以避免混淆
x, y = 1, 2
>>>x , y
for i,v in dic.items():
print(i,v)操作方法
访问
a. 成员必须是不可变的对象 b. 通过方括号索引访问里面的元素 c. 通过方括号切片访问里面的元素 ==> 返回的是元组类型 d. 在内存中通过 hashTable的方式存储 e. len()得到元素的个数
f. 可以使用for循环
内置方法
tuple()将可迭代对象转化为元组
print(tuple([1, 2, 4, 5]))方法
.count(value) 获取某个特定值出现的次数
.index(value, start=None, end=None) 返回某个特定值在指定范围的indextup = [1, 2, 3, 2, 'name', 4, 5, 6, 2, 2] print(tup.count(2)) print(tup.index('name'))
字典
python 中一种无序的key-value的数据类型，用来存储数据，读取速度快
特点：无序，key只能是不可变对象（必须是可hash的）数字/元组/字符串
dict_test = {
'name': 'li_yao',
'age': 24,
'length': 18,
'sex': 'man',
'hobby': 'game',
}
dict_new = {
'name': 'Mary',
'book': 'python',
}操作方法
增加/添加
直接增加：dict_test['key'] = new_value 原来字典中存在则会覆盖
函数增加：dict_test.setdefault(key, default) 设置字典中没有的key的default值,默认为None
如果设置的是已经存在的key，那么就会返回该key对应的value,默认值没有效果# 常规增加 dict_test['address'] = 'china' print(dict_test) # 函数设置增加, 对已经存在的key设置无效 dict_test.setdefault('option', 'good') # dict_test.setdefault('option') 默认None print(dict_test) # 函数更新，有则覆盖，无则更新 dict_test.update(dict_new) print(dict_test)删除
del test_dict['name']
dict_test.pop(key) 删除字典中指定的key值对应的键值对，然后返回删除的值
dict_test.popitem() 删除最后一项（但是由于是无序的按道理应该不是是删除最后一项）
dict_test.clear() 清空
{} = dic_test()# 删除 dict_test.pop('age') print(dict_test) # 随机删除 dict_test.popitem() print(dict_test) # del 关键字删除 del dict_test['hobby'] print(dict_test) # 清空 # dict_test.clear() # print(dict_test) # 删除字典 # del dict_test改
# 改 dict_test['length'] = 20 print(dict_test) # update 也算改的话,更新的是已经存在的key查
通过方括号语法，根据键来查找值，如果没有的话就会报错
dict_test .get(key, default_return=None) 通过指定key值来获取对应的value，无则返回默认指定的值
但是这个方法有bug，如果value是None的话，就不能确定到底这个key在不在字典中
dict_test.keys() dict_test.values() dict_test.items()# 常规查 value = dict_test['address'] print(value) # get函数查找 找不到默认返回None 可以设置默认值 # value1 = dict_test.get('address') value1 = dict_test.get('now_address', 'bei_jin') print(value1) # 特殊方法获取 key value item for key in dict_test.keys(): print(key) for value in dict_test.values(): print(value) for key, value in dict_test.items(): print(key,value)
集合set
- 大括号组成
- 元素必须是唯一的，而且是不可变对象
创建集合
# 创建集合: **元素必须是不可变对象**
# 可以直接创建
set_test = {1, 2, 3, 'name', 'age',}
#使用set函数，传入list或者dict类型,最好通过变量传递
l = [1, 2, 3, 'age', 'name']
set_test1 = set(l)
d = {'a': 1, 'b': 2}
set_test2 = set(d)操作方法
增
.add(value)
.update(iterable) ---> 会遍历然后添加进去,同时也要注意必须是不可变的对象# 增加 set_test.add('length') set_test.update(['old', 'young'])删除
.pop() 随机删除,然后可以返回函数值
.remove(value) 删除，没有返回值
.clear()
del set_testset_test.pop() set_test.remove('name') print(set_test)查
for item in set_test: print(item) # print(set_test1)
集合运算
交集 &
反交集 ^并集 |
差集 -子集/超集（父集） < >
# 交集
insert = set_test & set_test1
print(insert)
#{1, 2, 3, 'age', 'name'}
# 反交集
ainset = set_test ^ set_test1
print(ainset)
# {4, 5, 6, 'length'}
# 并集
union = set_test | set_test1
print(union)
# {1, 2, 3, 4, 5, 6, 'length', 'age', 'name'}
# 差集
c = set_test - set_test1
print(c)
# {'length'}
扫一扫
875
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
