一、简介
python是由吉多·范罗苏姆创建的，开发效率高可移植可扩展可嵌入，缺点是运行速度慢、不能加密、不能多线程运行。目前python的主要方向是云计算、WEB开发、科学运算、人工智能、系统运维、金融、图形GUI，python是解释型语言通过Cpython解释器进行解释，转化成机器能识别的语言，python通常使用pycharm进行开发。
二、安装
在官网www.python.org下载python3.5以上安装包进行安装，注意path下打勾（配置环境变量），这样在控制台上输入python就可以显示版本信息，安装python2.7版本时有时环境变量会不成功，这时在安装路径下复制python.exe重命名为python2.exe就可以了
在网上搜索下载pycharm及notepad安装
三、hello world
1、在控制台上直接编代码，控制台输入python后在光标后敲代码就行了
print("hello world")
需要注意的是这个print后面不用加分号
2、使用记事本或者notepad编写，只要文件类型为.py就可以
在控制台上转到python代码所在路径，然后输入命令python 文件名.py
四、数据类型
变量：变量由数字、字母、下划线组成，以字母做开头，使用驼峰体或者下划线命名，驼峰体: 除首字母外的其他每个单词首字母大写，如PythonTest,下划线: 每个单词之间用下划线分开如python_test
常量：python中没有绝对常量，只是约定把变量名字母全为大写的称为常量，并不再改变其值
注释：使用 # 注释单行，使用''' '''‘注释多行
整数：int 字符串：str字符串使用单引号' ' 或双引号 " " 或三个单引号 ''' ''' 或三个双引号 """ """，其中三个单引号和三个双引号可以换行。
布尔值（bool）:只有真（True）假(False) 注意拼写
将字符串转化为整数型
a="10" b="20" print(a+b) print(int(a)+int(b))
五、语句
1、交互语句
输入 input("提示语句")
输出 print("输出内容")
a=input("请输入一个数值") print(int(a)+10)
需要注意的是input得到的是输入内容的字符串，查看一个变量的类型可以使用type命令
a=10 b="123" type(a) type(b)
2、if语句
a=8 if a>10: print("a>10") elif a>5: print("a>5") else: print("a<5")
注意python中缩进很重要，if的代码区应相对于if缩进一个tab键，while也是这样，代码缩进相同表明代码处于同一级别，不存在嵌套。
3、while循环
a=1 while True: if a>10: break if a==3: a=a+1 continue print(a) a=a+1
break跳出所在循环并结束此循环，continue跳出所在循环执行此循环的下一个循环。
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
一.while的补充
index = 0
while index < 5: #一般令index初始化为0,在while循环中 index小于几就循环几次
if index == 3:
break # break的时候不会执行while后面的else,while和else是个整体,break跳出的是这个整体
print("旭哥")
index = index + 1
else: # 条件不成立. 执行的代码
print("梁姐")
二.内容是否包含一些敏感词 in not in
in判断某个字符串是否在某一段字符串中,not in 相反,判断某个字符串是否不再某一段字符串中
# in 可以帮我们判断xxx字符串是否出现在xxxxxxx字符串中
content = input("请输入你的评论:")
# 马化腾是特殊字符
if "马化腾" in content:
print("非法的")
else:
print("合法的")
# not in 没有出现xxx
三.格式化输出 %
print("我叫%s, ,我今年%d岁,我喜欢%s,我们学习python已经2%%了" % ("sylar",18,"编程"))#当%在一个语句中先作为了占位符,那如果想输出%,需要写两个%,表示转义
# ****格式化输出
a = '123'
b = f"6666{a}"
print(b)
# 6666123
四.运算符
+ 加 - 减 * 乘 / 除(这个除就是除以,不能整除就转化成小数) ** 取幂 % 取余 // 取商
== 等于 != 不等于 <> 不等于(Python中不常用) < 小于 >大于 <=小于等于 >=大于等于 这些运算后结果返回True或者False
and 与 or 或 not 非 ()优先级最高,然后是not,然后是and最后是orprint(0 or 5)
5
print(5 or 0)
5
print(0 and 5)
5
print(5 and 0)
0 #and 中有0就输出0,or中有非0的数就是非零的数,混合的时候看第一个数or第一个数是0,得值为第二个数,第一个数不为0,得值为第一个数;
# and相反第一个数是0,得值为第一个数即0,第一个数不为0,得值为第二个数
#
print(3>5 and 5)#这个结果为False ,False和0的概念相同,但是False并不是0,False是False 0是0
五.编码 ASCII Unicode UTF-8
ASCII码 8bit 一个byte字节 共2**8即256种
GBK码 英文一个字节 8bit 中文16bit 两个byte字节 共2**16
Unicode 32bit 4个byte 共2**32
UTF-8是在Unicode基础上的长度可变的编码,最小长度为8bit,中文字符是24bit,3个字节
8bit=1byte
1024byte=1KB
1024KB=1MB
1024MB=1GB
1024GB=1TB
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
一.数据类型
1. int 整型 bit_length() 返回整型数值的二进制长度
a = 15 #15的二进制码是1111,当然存储是以字节为单位的00001111,看电脑是32位还是64位在前补零 print(a.bit_length()) # 求的是有效长度,从第一个不为0开始数 #4
2. str
除了赋值操作,任何以下的函数都不会改变原字符串,只会返回一个新的字符串.列表则不同.函数操作是直接在原列表上进行的,
字符串的增使用"+"连接,倍增用 "*" 连接 ,删replace替换strip去除左右两端的字符,切片,split切割列表,查find.index
列表的增insert append extend ,删 pop remove del clear ,改切片直接赋值,没有replace, 查index
字典的增,直接dic[]="",updata,删 pop del,改直接赋值,查dic["name"] 遍历查
s="abcdefg" s[2] #索引 s[2:3] #切片 s.split(**) #切割,返回列表 s.count(**) #数数,返回个数 s.find(**) #返回索引 s.index(**) #返回索引 len(s) #返回字符串的长度,和print一样是Python的内置函数
*****以下是条件判断语句返回True或者False s.startswith(**) #判断字符串是否以**开头,返回True或者False s.endswith(**) #判断字符串是否以**结尾,返回True或者False s.isalnum() #判断字符串是否是中文字母和数字组成 s.isdigit() #判断字符串是否是纯阿拉伯数字 s.isalpha() #判断字符串是否是字母或中文
s.encode("utf-8").isalpha #判断字符串是否为全英文
s.isnumeric() #判断字符串是否是数字,包括一二三 个十百 壹贰这些 *****判断语句结束******** "abc{}".format() #格式化输出
*******字符串大小写字母的问题****** s.capitalize() #字符串首字母变为大写,其余字母变为小写,原来是大写也变为小写 s.title() #所有单词(被特殊字符分割都认为是单词,中文也算特殊字符)首字母变为大写 s.upper() #变为大写字母 s.lower() #变为小写字母 s.swapcase() #大小写互换
s.center(10,"*") #拉长成10, 把原字符串放中间.其余位置补*
s.expandtabs()
s.strip() #去掉左右两端的空格
s.strip("**") #去掉左右两端指定元素
s.strip("a" "b") #去掉左右两端的"a"和"b"
s.replace("原字符","新字符","替换的个数")
#######索引 s="abcdefg1234567" print(s[2]) #从0开始从左往右数,所以这里打印的是第三个字符"字" #c print(s[-1]) #-1表示的是倒数第一个 #7 ######切片 print(s[1:4]) #输出索引位置为 1 2 3出的字符,注意这个[]只包括左边的数,顾头不顾尾 #bcd print(s[1:4:2]) #2为步长,每两个输出一个,输出第一个 #bd print(s[4:1:-1]) #要想从右往左输出,步长必须为负,即当s[第一个索引:第二个索引:步长],第一个索引对应字符串在第二个索引左边时,步长必须为正,默认是1,第一个索引对应的字符串在第二个索引的右边时,则步长必须为负 # edc print(s[-1:-4:-2]) #75 print(s[1:])#从索引1处到最后 #bcdefg1234567 print(s[:-1])#从开始到倒数第二个,-1是最后一个,但是注意[]顾头不顾尾 #abcdefg123456 print(s[:])#原样输出
######切割 split
s="a_b_c_d_e"
li=s.split("_") #以下划线作为刀切割字符串,原字符串中所有下滑线的左右两侧变为两个字符串,并返回一个列表,即字符或者字符串如作为刀则一定能切,且至少切成两份
print(li)
#['a', 'b', 'c', 'd', 'e']
li=s.split("_",2) #第二个参数是切得个数,从左到右开始切,切两次就不切了
print(li)
#['a', 'b', 'c_d_e']
li=s.split("g") #字符串中没有刀,不能切,返回原字符串
print(li)
#['a_b_c_d_e']
#li=s.split("") #这个刀为空,报错,
li=s.split("a") #所谓一刀两断,a的左边认为是空字符
print(li)
#['', '_b_c_d_e']
s = "abc s k "
li = s.strip().split(" ")
print(li)
['abc', '', '', 's', '', '', 'k'] 这是按空格切出来的结果会有很多空字符串
while "" in li:
li.remove("") #清除空字符串,
print(li) # 或者使用下面这种方法 li = [i for i in li if i!=""] #清除空字符串 print(li) # 其实直接使用split() 不加参数切就行了 li = s.strip().split() print(li) #['abc', 's', 'k']
s = """诗人
学者
感叹号
渣渣"""
print(s.split("\n")) # 用\n切割
count 数数
s = "alex wusir taibai "
print(s.count("ai")) #输出ai在s字符串中的个数
#2
find 查找
s = "明天周末了.你们打算干什么去?"
print(s.find("了")) # 如果查找的内容不存在. 返回-1, 如果存在返回索引
#4
print(s.find("我"))
#-1
s.find("a", 8, 22) # 切片找,从索引为8-21中找"a"的索引位置
index 求索引
#index 求索引
s = "下周我们要考试了. 你们慌不慌"
print(s.index("们要"))
#3
format 格式化输出
#格式化输出
print("我叫%s,今年%d岁" % ("perfey",24))
#我叫perfey,今年24岁
print("我叫{},今年{}岁".format("perfey",24))
#我叫perfey,今年24岁
print("我叫{1},今年{0}岁".format(24,"perfey")) #可以指定参数的位置,不必按顺序对应了
#我叫perfey,今年24岁
print("我叫{name},今年{age}岁".format(name="perfey",age=24)) #通过有意义的名称作为参数进行对应
#我叫perfey,今年24岁
3. bool
True False
认为字符串有内容为真,无内容为假. 即只有""字符串为假,其余的字符串均为真
空字符串是False. 非空字符串是True
向系统中录入员工信息, 不停的录入 , 输入回车退出
while True:
name = input("输入用户信息:")
if not name: 当不输入信息即直接回车时,name为空,认为是False
break
else:
print("新员工信息:"+name)
for 迭代
for 变量 in s: #把s中的元素逐个的放到变量中
代码块
int str bool三种类型的转换
str => int int(str)
int => str str(int)
int => bool bool(int). 0是False 非0是True
bool=>int int(bool) True是1, False是0
str=>bool 在判断语句中如 if while不用转换,解释器自己转换;在其他语句中 bool(str)
s=""
if not s:
print(bool(s))
#False
4. list [] 列表
字符串转化为列表,可以使用split或者extend,但是因为split切割时会有消耗,所以一般使用extend进行迭代的追加
************************列表*******************
li=[1,'a','b',2,3,'a']
li.insert(0,55) #按索引插入
li.append('aaa') #增加到最后
li.extend(['q,a,w','aaa']) # 迭代的增加 用[]括起来表示是一个元素
#[1, 'a', 'b', 2, 3, 'a', 'q,a,w', 'aaa']
li.extend('a')
li.extend('abc') #把字符串的每个元素分别作为元素加入到列表后面
li.extend('a,b,c')
li.pop(1) #从0开始数,把第一个元素删除.有返回值返回删除的元素
pop是堆栈中的概念,相对于push,向外弹,从后往前弹
li.pop() #删除最后的值
del li[1:3] #把1 2元素删除,注意这个[]是类似于前闭后开,没有3元素.没有返回值.del不是函数,只要是函数就有小括号,del是关键字
print(li)
li.remove('a') #删除指定的元素
li.clear() #清空列表所有元素
li=[1,2,3,4,5] li[1]='11' #将索引2处的值改为11 print(li) li[2:4]='ab' #将索引 2 3 处的值改为 "a" "b" print(li) #[1, '11', 'a', 'b', 5] li[2:4]=['ab','c'] #将索引 2 3 处的值改为 "ab" "c" print(li) #[1, '11', 'ab', 'c', 5]
li[0:4:2]="ab" #步长为2,步长不为1时元素个数必须要匹配,不匹配会报错
#[a,"11","b","c",5]
print(li.count(5)) #列表中有多少个5 print(li.index('11')) #查找某个值的索引 a=[2,1,3,4,5] a.sort() #将a中的元素排序 print(a) #[1, 2, 3, 4, 5]
a.sort(reverse=True) #降序
#[5, 4, 3, 2, 1]
a=["1","12","112","5","9"]
a.sort()
#['1', '112', '12', '5', '9'] #这里是字符串,是一位一位进行比较排序的,注意汉字不能排序
a=[2,1,3,4,5] a.reverse() #将a中的元素反向排列 print(a) #[5, 4, 3, 1, 2]
s = "*".join(lst) # 把列表变成字符串. 用前面的字符串"*"把列表连接起来, 返回新字符串 (字符串\元组也有同样的操作,可迭代,有顺序)
lst = ["黄飞鸿", "霍元甲", "十三姨", "鬼脚七"]
s = "_*_".join(lst) # 把列表变成字符串. 用前面的字符串把列表连接起来, 返回新字符串
print(s)
#黄飞鸿_*_霍元甲_*_十三姨_*_鬼脚七
s = "金毛狮王"
s1 = "_".join(s) # 迭代把每一项进行拼接
print(s1)
# 金_毛_狮_王
tu = ('你好', "你不好", "你好不好")
s = "".join(tu)
print(s)
# 你好你不好你好不好
#join 和 split结合使用可以字符串变成列表
s = "你今天准备什么时候睡觉"
s1 = "_".join(s) # 你_今_天_...
lst = s1.split("_")
print(lst)
# ['你', '今', '天', '准', '备', '什', '么', '时', '候', '睡', '觉']
5. tupe () 元组,只读列表,不能更改
tupe () 元组 只读列表 可以被查询,不能修改,字符串的切片操作也可用于元组
元组和列表之间可以直接转化
tu1 = tuple(lst)
lst1 = list(tu1)
tu=(1,) 如果只有一个元素,元素后边必须加逗号
tupe本身不能变,但是二级元素可以变,tupe的儿子不可变,孙子可变
6. dict {} 字典,查找比较快. key:value, 一次存两个数据. 一对一对的存
**********************************字典*************************************
dic={'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'} #定义了一个字典
print(dic) #字典的顺序是哈希算法决定的,与我们输入的顺序无关,所以字典不能切片
print(dic['age']) #输出键'age'对应的值,注意这里的键的数据类型是字符还是变量还是整型的
#18
print("name" in dic) # 看字典中是否有"name这个键值"
#True
dic[5]=9 #新增键值对,在最后增加,原字典中有键值的话会修改为现在的value
print(dic)
#{'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v', 5: 9}
dic.setdefault('k','v1') #setdefault(设置默认值) 在字典中添加键值对，返回值是value,如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖
print(dic)
#{'age': 20, 'name': 'jin', 'sex': 'male', 'k': 'v'}
dic["age"]=20 #更改键对应的值
print(dic)
#{'age': 20, 'name': 'jin', 'sex': 'male', 'k': 'v', 5: 9}
del dic[5] #删除键值对,这个是删除键5对应的键值对.没有返回值
print(dic) #{'age': 20, 'name': 'jin', 'sex': 'male', 'k': 'v'} dic.pop("k") #删除"k"对应的键值对,注意这里的pop内的参数不能为空,因为没有顺序,不同于列表,列表是弹出最后一个 print(dic) #{'age': 20, 'name': 'jin', 'sex': 'male'}
dic.popitem() #随机删除一个键值对,返回元组,元组里保存删除键值对的键和值
k,v = dic.popitem #通过解构,将返回值 键放到k中,将值放到 v 中;字符串,列表,元组也可进行此操作,只是注意等号左边的变量要和右边的元素数一致
print(k)
print(v)
dic = {"name":"jin","age":18,"sex":"male"} dic2 = {"name":"alex","weight":75} dic2.update(dic) # 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中 print(dic2) #{'name': 'jin', 'weight': 75, 'age': 18, 'sex': 'male'} value1=dic["name"] #得到键name对应的值,没有报错 print(value1) #jin value2=dic.get("djdd","默认返回值") #得到键djdd对应的值,没有返回参数2 print(value2) #默认返回值 print(dic) item1 = dic.items() print(item1,type(item)) # dict_items([('name', 'jin'), ('sex', 'male'), ('age', 18)]) <class 'dict_items'> # 这个类型就是dict_items类型，可迭代的 同样的keys values也可以 key1 = dic.keys() #这里的item1 .key1. value1只是变量名 #dict_keys(['name', 'age', 'sex']) #可以把dic.keys()当做列表
for le in dic.keys():
print(le) #得到key
print(dic.get[le]) #得到key对应得value
value1 = dic.values() #dict_values(['jin', 18, 'male']) for key5 in dic.keys(): #遍历字典的key值,key5只是一个变量名 print(key5) for value in dic.values(): #遍历字典的value值,value亦只是个变量名 print(value) for item in dic.items(): #遍历字典的项元素 print(item) for key,value in dic.items(): print("key=%s,value=%s" % (key,value) )
可以认为key5 是所有键组成的列表,value是所有值组成的列表,item是键值对组成的列表,而其中的键值对是键和值组成的元组
for item in dic: # 直接循环迭代的时候拿到的是key
# 把第一个参数中的每一项拿出来和第二个参数组成一个键值对
# 生成出来的键指向的value是同一个对象. 改变其中一个的时候. 另一个也会跟着改变
#fromkeys是静态方法,返回字典但原字典不变
dic = dict.fromkeys(["jay", "jj"], ["周杰伦", "林俊杰"])
print(dic)
# {'jay': ['周杰伦', '林俊杰'], 'jj': ['周杰伦', '林俊杰']}
dic['jay'].append("蔡依林")
print(dic)
# {'jay': ['周杰伦', '林俊杰', '蔡依林'], 'jj': ['周杰伦', '林俊杰', '蔡依林']}
7. set {} 集合,一次存一个. 不能重复. 只存key, 比较少见
& 交集 | 并集 - 差集 ^反交集
#******************集合********************
#集合是无序的，不重复的数据集合
#它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：
#去重，把一个列表变成集合，就自动去重了。
#关系测试，测试两组数据之前的交集、差集、并集等关系
li=[1,1,2,2,"a"] #将列表变为集合,去重
set1=set(li)
print(set1)
#{'a', 1, 2}
li.clear()
li.extend(set1) #将去重后的集合变回成列表,当然顺序不可避免的改变了
set1=set({1,2,3} ) #创建集合的两种方法 ,可以使用set创建,也可以直接赋值
set2={1,2,3,4,5,6} set1.add("4") #增加 set1.update(["a","b","c"]) #迭代增加 #{1, 2, 3, '4', 'c', 'a', 'b'} set1.remove('a') # 删除一个元素 set1.pop() # 随机删除一个元素,因为是无序的所以随机删除 set1.clear() # 清空集合 print(set1) #set() del set1 # 删除集合 print(set1 < set2) #True print(set1.issubset(set2)) #set1是set2的子集 #True print(set2.issuperset(set1)) #set2是set1的超集 #True s=frozenset("barry") #frozenset不可变集合,让集合变为不可变类型 print(s,type(s)) #frozenset({'a', 'r', 'y', 'b'}) <class 'frozenset'> l1=[1,2,2,["barry","alex"]] l2=l1 l3=l1.copy() l1[1]=222 l1[3][1]="wusir" print(l1,id(l1)) #[1, 222, 2, ['barry', 'wusir']] 2275223314952 print(l2,id(l2)) #[1, 222, 2, ['barry', 'wusir']] 2275223314952 print(l3,id(l3)) #[1, 2, 2, ['barry', 'wusir']] 2275223317448 print(l1,id(l1[3][1])) #[1, 222, 2, ['barry', 'wusir']] 2275223306792 print(l3,id(l3[3][1])) #对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性 #[1, 2, 2, ['barry', 'wusir']] 2275223306792 import copy l4=copy.deepcopy(l1) #深拷贝deepcopy保证每层的copy地址都不同 l4[3][0]="wusir" print(l1,id(l1[3][0])) #[1, 222, 2, ['barry', 'wusir']] 2275223306288 print(l4,id(l4[3][0])) #[1, 222, 2, ['wusir', 'wusir']] 2275223306792
无论是深拷贝还是浅拷贝对于不可变的元素(整型,字符串,元组)其内存地址是一样的,直至在列表中替换这个元素,因为深拷贝的目的就是防止一个的操作对另一个复制品的值产生影响,而不可变量是不可变的,所以不会有影响
1. 赋值是将一个对象的地址赋值给一个变量，让变量指向该地址（旧瓶装旧酒）。
2. 浅拷贝是在另一块地址中创建一个新的变量或容器，但是容器内的元素的地址均是源对象的元素的地址的拷贝。也就是说新的容器中指向了旧的元素（新瓶装旧酒）。
3. 深拷贝是在另一块地址中创建一个新的变量或容器，同时容器内的元素的地址也是新开辟的，仅仅是值相同而已，是完全的副本。也就是说（新瓶装新酒）。
能转换成False的数据类型有哪些
0, '', [], (), {}, None, set(), False
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
for
msg = 'hello world'
for item in msg: #遍寻字符串
print(item)
li = ['alex','银角','女神','egon','太白']
for i in li: #遍寻列表
print(i)
#alex
#银角
#女神
#egon
#太白
dic = {'name':'太白','age':18,'sex':'man'}
for k,v in dic.items(): #遍寻字典
print(k,v) #name 太白 #age 18 #sex man
else:的应用
if 条件:
代码块
elif 条件:
代码块
else:
条件不成立时执行
while 条件:
代码块
else:
条件不成立且代码块中无break执行
for index in li: #或者dic 或者字符串 或者range(range可以把他当做一个多少次的循环)
代码块 else: 循环执行完且代码块中无break执行
迭代本质上是对可迭代对象按索引或者key逐一进行操作的,当在迭代过程中首先获取可迭代对象的元素个数,并以此作为循环的次数,按照索引从0开始递增找到索引对应的元素,如果在迭代过程中对可迭代对象进行了删除,会导致索引的变化和元素的减少,当循环到删除后的可迭代对象没有循环的索引时就会停止循环,而且现在的索引与迭代开始时索引对应的元素不同,此时再进行操作很容易出错,所以解决的办法就是把循环次数和原数据索引分开,使用迭代删除时,首先把要删除的数据保存在一个新的列表(字典.字符串')中,然后迭代这个列表,在这个迭代中使用删除命令删除原数据中的元素
lst = ["倚天屠龙记", "诛仙", "看见", "追风筝的人"]
for i in lst:
del lst[0]
print(lst)
#['看见', '追风筝的人'] 因为当删除两个之后找不到索引2对应的元素了,所以for循环结束 ["看见","追风筝的人"]没有被删除
# 正确
for i in range(0, len(lst)):
del lst[0] print(lst) for i in range(0, len(lst)): lst.pop() print(lst) # 把要删除的东西保存在一个新列表中,下面这个例子是清空操作(不使用clear) lst = ["倚天屠龙记", "诛仙", "看见", "追风筝的人"] new_lst = [] for el in lst: new_lst.append(el) # 循环新列表. 删除老列表 for e in new_lst: lst.remove(e) print(lst)
enumerate 枚举
#枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值
li = ['alex','银角','女神','egon','太白']
for i in enumerate(li):
print(i)
#(0, 'alex')
#(1, '银角')
#(2, '女神')
#(3, 'egon')
#(4, '太白')
for index, name in enumerate(li,100): # 起始位置默认是0，可更改
print(index, name)
#100 alex
#101 银角
#102 女神
#103 egon
#104 太白
range 指定范围，生成指定数字
for i in range(1,10): #依次输出1-10
print(i)
for i in range(1,10,2): # 步长
print(i)
for i in range(10,1,-2): # 反向步长
print(i)
# *******************补充变量的存储地址***************
详细讲解:https://www.cnblogs.com/jin-xin/articles/9439483.html is 和 == 的区别 id(变量) 返回变量的内存地址 is 比较的是变量的内存地址 == 比较的是值 s="123" print(id(s)) #1714629420176 每次执行,内存地址得到的是不同的 小数据池(常量池): 把我们使用过的值存储在小数据池中.供其他的变量使用. 小数据池给数字和字符串使用, 其他数据类型不存在. 对于数字: -5~256是会被加到小数据池中的. 每次使用都是同一个对象. 对于字符串串: 1. 如果是纯数字信息和下划线. 那么这个对象会被添加到小数据池 2. 如果是带有特殊字符的. 那么不会被添加到小数据池. 每次都是新的 3. 如果是单个字母*n的情况. 'a'*20, 在20个单位内是可以的. 超过20个单位就不会添加 到小数据池中 注意(一般情况下): 在py⽂文件中. 如果你只是单纯的定义一个字符串. 那么一般情况下都是会 被添加到小数据池中的. 我们可以这样认为: 在使用字符串的时候, python会帮我们把字符串 进行缓存, 在下次使用的时候直接指向这个字符串即可. 可以节省很多内存.
存放变量名,可以把变量名理解为指针,里面可以存储变量内容的内存地址,变量名之间的直接赋值如V1=V2是内存地址的传递,变量内容赋值给变量名如V1="123",是在内存中开辟一个区域存储"123",同时将这个内存地址赋值给V1,使V1指向"123",当然变量在内存中开辟地址时使用的是小数据池还是其他位置,取决于变量的内容,详见上面小数据池的说明
#**********************编码及转化*******************************
# ASCII 8bit 1byte 英文小写大写字母. 特殊字符. 数字
# GBK 16bit 2byte 中文 兼容ASCII
# UNICODE 32bit 4byte 万国码. 占空间 浪费
# UTF-8 unicode升级版, 英文 1byte, 中文 3byte
#
# 传输过程中用: UTF-8或者GBK. UNICODE 浪费资源.
# 内存中, 我们程序运行的过程中. 编码是unicode,所以程序在网络中运行时需要先转码再发送,在程序中.字符串可以编码成bytes类型的数据,使用编码encode()编码
# 转换的时候. GBK不能和UTF-8互相转换.
s="你"
print(s.encode("GBK"))
#b'\xc4\xe3'
print(s.encode("UTF-8"))
# b'\xe4\xbd\xa0' 这就是把字符串编码成bytes类型的数据,b'表示是bytes类型,\x表示是16进制,中文使用UTF-8是3个字节 e4 bd a0就是这三个字节
print("nihao你好".encode("UTF-8"))
#b'nihao\xe4\xbd\xa0\xe5\xa5\xbd' 混合使用
#解码是decode print(s.encode("UTF-8").decode()) #你
英文的bytes: b'英文'不会再变成16进制码
扫一扫
835
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
