标签：11 jason name python age 123 print
垃圾回收机制
1.引用计数: 内存中的数据如果没有任何的变量名与其有绑定关系,那么会被自动回收
2.标记清除: 当内存快要被某个应用程序占满时会自动触发,停止程序的运行，检测所有变量与值的绑定关系，给引用计数为0的值打上标记最后一次性清除
3.分代回收: 根据值存活时间的不同,划为不同的等级,等级越高垃圾回收机制扫描的频率越低
变量和常量
变量
变量名的命名规范:
1.只能包含数字,字母,下划线
2.数字不能开头
3.关键字不能作为变量名
通常变量名的命名有两个流派:
驼峰体(前端语言js推荐的命名方式)
userName
下划线(python推荐的命名方式)
user_name
注意: 变量必须先定义后调用,变量名一定要起的有意义(见名知意),千万不要用中文
变量的三要素:
id(): 返回的是一串数字,可以直接理解为内存地址
type(): 返回的是该变量对应的数据的类型
value: 该变量指向的内存当中的数据值
小整数池(1-256):
>>> a = 257
>>> b = 257
>>> id(a)
2919979319120
>>> id(b)
2919979576208
>>> c = 256
>>> d = 256
>>> id(c)
1642892736
>>> id(d)
1642892736
常量
常量(不可变的量)
python里面压根没有常量
通常将全大写的变量名看作常量(python程序员约定俗成的)
输入输出
输入
name = input('please input you username>>>: ')
格式化输出
name = 'jll'
age = 18
print('my name is',name,'my age is',age) # my name is jll my age is 18
# 占位符 %s %d
print('my name is %s my age is %s'%(name,age)) # my name is jll my age is 18,谁先来谁先坐,个数必须一致不能多也不能少
print('my name is %s my age is %d'%(name,age)) # %d只能给数字占位,%s可以给任意数据类型占位
print('%08d'%123) # 00000123,整数是8位,传入的数不够八位前面用0补全,超出8位,是多少就是多少
数据类型
数值类型
整型（不可变）
age = 18 # age = int(18)
方法
# int()
print(int()) # 0
print(int(3)) # 3
print(int(3.6)) # 3
print(int('1100',2)) # 12 二进制'1100'转成十进制
print(int('14',8)) # 12
print(int('c',16)) # 12
# bin()
print(bin(12)) # 0b1100 十进制转二进制,0b表示后面的数字是二进制数
# oct()
print(oct(12)) # 0o12 十进制转八进制,0o表示后面的数字是八进制数
# hex()
print(hex(12)) # 0xc 十进制转十六进制,0x表示后面的数字是十六进制数
浮点型（不可变）
salary = 1.11 # salary = float(1.11)
复数
a = 1-2j
print(type(a)) # <class 'complex
print(a.real) # 1.0 查看实部
print(a.imag) # -2.0 查看虚部
长整型（python2）
a = 123
print(type(a)) # <type 'int'>
b = 12345678910111213141516171819 # 定义长整型: b = 1L
print(type(b)) # <type 'long'> 只有python2中才有长整型的概念,python3里面只有整型
字符串（不可变 有序）
# 定义,之所以有三种定义方式是考虑到用户在输入的文本中也需要用到引号
# 第一种 单引号
s1 = '我是字符串,jason说: "天下无敌"' # 我是字符串,jason说: "天下无敌",s1 = str('XXX')
# 第二种 双引号
s2 = "我是字符串,jason说: '天下无敌'" # 我是字符串,jason说: '天下无敌'
# 第三种 三引号(可以是单也可以是双,并且可以写多行,但是不能混合使用)
s3 = '''
我是字符串
并且可以写多行
'''
s4 = """
我是字符串
并且可以写多行
"""
# python中的字符串支持加和乘操作
s5 = 'hello'
s6 = 'world'
print(s5+s6) # helloworld
print(s5*3) # hellohellohello
# str() 所有类型都可以转成字符串类型
s1 = str([1,2,3,4])
print(type(s1)) # <class 'str'>
内置方法
# 1. strip() lstrip() rstrip()
# 默认去除字符串首尾的空格,也可指定其它符号
print(' jason '.strip()) # jason
print('$$jason$$$'.strip('$')) # jason
print('% ￥#jason&*)'.strip('% ￥#*')) # jason& 指定去除多个字符
print('$$jason$$$'.lstrip('$')) # jason$$$$ 只去除左边字符
print('$$jason$$$'.rstrip('$')) # $$$$jason 只去除右边字符
# 2. split() rsplit()
# 切分,针对按照某种分隔符组织的字符串,可以用split将其切分成列表,进而进行取值,如果不指定切割个数那么split和rsplit效果是一样
data = 'jason|123|handsome'
print('data'.split('|')) # ['jason','123','handsome'] 切割的顺序是从左往右的
username,password,info = data.split('|')
print(data.split('o',1)) # ['jas','n|123|handsome'] 从左往右只切一个
print(data.rsplit('o',1)) # ['jason|123|hands','me'] 从右往左只切一个
# 3. lower() upper()
print('JaS1oN'.lower()) # jas1on 转小写
print('JaS1oN'.upper()) # JAS1ON 转大写
# 4. startswith() endswith()
print('egon is dsb'.startswith('egon')) # True 判断字符串是否以什么什么开头
print('egon is dsb'.endswith('n')) # False 判断字符串是否以什么什么结尾
# 5. format()
# 第一种,按位置占位,跟%s原理一致
str1 = 'my name is {} my age is {}'.format('jason',18)
# 第二种,按索引占位
str1 = 'my name is {1} my age is {0}'.format('egon',18) # my name is 18 my age is egon
# 第三种,指名道姓占位（关键字传参）
str1 = 'my name is {name} my age is {age}'.format(name='jason',age=18)
# 6. join()
# 将容器类型中的多个元素通过指定字符拼接成一个字符串,join拼接时容器中的每个元素类型都要是一样的
res_list = ['jason','123','handsome']
res_str = '$'.join(res_list)
print(res_str) # jason$123$handsome
# 7. replace 替换
str = 'egon is dsb and egon has a BENZ'
print(str.replace('egon','kevin')) # kevin is dsb and kevin has a BENZ
print(str.replace('egon','kevin',1)) # kevin is dsb and egon has a BENZ 从左往右只替换一个
# 8. isdigit() 判断字符串中包含的是否为纯数字
age = input('>>>: ')
print(age.isdigit())
# 9. find() rfind() index() rindex()
# find和index的区别是,find找不到返回-1,index找不到报错
s = 'kevin is dsb o and kevin is sb'
print(s.find('dsb')) # 返回的是d字符所在的索引值
print(s.find('xxx')) # 找不到不报错返回-1
print(s.find('i',0,3)) # 通过索引来限制查找范围
print(s.index('o')) # 返回所传字符所在的索引值
print(s.index('xxx')) # 找不到则报错
print(s.index('v',0,3)) # 通过索引来限制查找范围,顾头不顾尾
# 10. count()
print('kevin is dsb o and kevin is sb'.count('n')) # 统计字符出现的次数
# 11. center() ljust() rjust() zfill()
print('jason.center(12,'*')) # ***jason****
print('jason.ljust(12,'$')) # jason$$$$$$$
print('jason.rjust(12,'$')) # $$$$$$$jason
print('jason.zfill(12)) # 0000000jason
# 12. expandtabs() 指定tab键的空格数
s10 = 'a\tbc'
print(s10) # a bc
print(s10.expandtabs(6)) # a bc
# 13. captalize() swapcase() title()
print('hElLo WoRLD sH10'.capitalize()) # Hello world sh10 首字母大写
print('hElLo WoRLD sH10'.swapcase()) # HeLlO wOrld Sh10 大小写互换
print('hElLo WoRLD sH10'.title()) # Hello World Sh10 每个单词的首字母大小
# 14. isnumeric() isdecimal() isdigit() is数字系列,判断是否为数字
num1=b'4' # bytes
num2=u'4' # unicode python3中无需加u就是unicode
num3='壹' # 中文数字
num4='Ⅳ' # 罗马数字
# ''.isnumeric(): unicode,中文数字,罗马数字
print(num2.isnumeric()) # True
print(num3.isnumeric()) # True
print(num4.isnumeric()) # True
# ''.isdecimal(): unicode,只识别普通的阿拉伯数字
print(num2.isdecimal()) # True
print(num3.isdecimal()) # False
print(num4.isdecimal()) # False
# ''.isdigit(): bytes,unicode,通常情况下使用isdigit就已经满足需求了
print(num1.isdigit()) # True
print(num2.isdigit()) # True
print(num3.isdigit()) # False
print(num4.isdigit()) # False
# 15. isalpha() 判断字符串是否包含数字,包含返回False,不包含返回True
print('a'.isalpha()) # True
print('a'.isalpha()) # False
列表（可变 有序）
l = [123,3.1,'dbj',[11,22]] # l = list([...])
print(l[3][0]) # 11
# 能够被for循环的就能够被list转换,list内部原理就是for循环取值,然后一个个塞到列表中去
print(list('abc')) # # ['a','b','c']
print(list({'name': 'jason','password': '123'})) # ['name','password']
内置方法
# 1. append() insert() extend() 往列表中添加元素
l = [11,22,33,44,55]
l.append(66) # [11,22,33,44,55,66] 注意append只能将被添加的数据当作列表的一个元素
l = [11,22,33,44,55]
l.insert(2,96) # [11,22,96,33,44,55] 通过索引在任意位置添加元素,注意insert只能将被添加的数据当作列表的一个元素
l = [11,22,33,44,55]
l1 = [88,77,66]
l.append(l1) # [11,22,33,44,55,[88,77,66]]
l.insert(-1,l1) # [11,22,33,44,[88,77,66],55]
l.extend(l1) # [11,22,33,44,55,88,77,66] 添加容器类型数据,内部原理for循环l1一个个追加到列表的尾部
# 2. del pop() remove() 删除列表元素
l = [11,22,33,44,55]
del l[2] # del适用于所有烈性的删除操作,没有返回值
print(l) # [11,22,44,55]
l = [11,22,33,44,55]
res1 = l.pop() # l=[11,22,33,44] res1=55 尾部弹出,会将弹出的值返回给调用者
res2 = l.pop() # l=[11,22,33] res2=44
res3 = l.pop() # l=[11,22] res3=33
l = [11,22,33,44,55]
res = l.pop(2) # l=[11,22,44,55] res=33 可以指定索引,按照索引弹出元素
l = [11,22,33,44,55]
l.remove(33) # 指定要删除的元素的值,没有返回值
print(l) # [11,22,44,55]
# 3. count()
print(['a','b',1,8,8,'a'].count(8)) # 2
# 4. clear() 清空列表
l = ['a','b',1,8,8,'a']
l.clear()
print(l) # []
# 5. reverse() # 将列表反转
l = ['a','b',1,8,8,'a']
l.reverse()
print(l) # ['a',8,8,1,'b','a']
# 6. sort() 排序,默认情况下是从小到大(升序)
l1 = [43,6,1,7,99]
l1.sort()
print(l1) # [1,6,7,43,99]
l1.sort(reverse=True) # 可以通过指定参数来修改默认的排序规则(降序)
print(l1) # [99,43,7,6,1]
# 队列,先进先出
l1 = []
l1.append('first')
l1.append('second')
l1.append('third')
print(l1) # ['first', 'second', 'third']
print(l1.pop(0)) # first
print(l1.pop(0)) # second
print(l1.pop(0)) # third
# 堆栈,先进后出
l1.append('first')
l1.append('second')
l1.append('third')
print(l1) # ['first', 'second', 'third']
print(l1.pop()) # third
print(l1.pop()) # second
print(l1.pop()) # first
布尔
# 如果变量名存储的值是布尔值的话,那么约定俗成的变量名统一用is_开头
is_tag = True # tag = bool(True)
x = 10
y = 20
print(x == y) # False 单个等号是赋值,两个等号是比较,比较的仅仅是值是否相等
print(x is y) # False 比较的是两个变量对应的id是否相等
"""
id相等的情况下,值一定相等
id不相等的情况下,值有可能相等
"""
元祖（不可变 有序）
age=(11,22,33,44) # 本质 age=tuple((11,22,33,44))
t1 = tuple(1) # 报错,必须传容器类型
n = ('a') # 定义元组时,当只有一个元素且没有用逗号时,则不是定义成元组,而是会把()去掉定义成数值或字符串等
n1 = (1)
n2 = ('a',)
n3 = (1,)
print(type(n),type(n1),type(n2),type(n3)) # <class 'str'>,<class 'int'>,<class 'tuple'>,<class 'tuple'>
# 在定义容器类型的时候,哪怕内部只有一个元素,你也要用逗号隔开区分一下（******）
t = (1, 2, 3, 'a', 'b', [1, 2, 3])
t[1] = 'hahah' #元组不能改,报错
del t[-1] # 报错
t[-1][0] = 'hahah' #当元组里的元素是可变的容器类型则可以改
t[-1].append(4)
print(t) # t = (1, 2, 3, 'a', 'b', ['hahah', 2, 3,4])
内置方法
# 1. count()
t = (1, 2, 3, 'a', 'b', [1, 2, 3])
print(t.count('a')) # 1
# 2. index()
t = (1, 2, 3, 'a', 'b', [1, 2, 3])
print(t.index('a')) # 返回所传字符所在的索引值
print(t.index('xxx')) # 找不到则报错
print(t.index('a',0,3)) # 通过索引来限制查找范围,顾头不顾尾
字典（可变 无序）
key: value键值对
key是对value的描述,key通常情况下是字符串
key不能重复,要唯一标识一条数据,如果重复了,会按照最后一组重复的键值对存储
d = {'name': 'jason','password': 123} # d = dict({'name': 'jason','password': 123})
# 定义
# 方式一:
d1 = {'name': 'jason','password': 123}
# 方式二:
d2 = dict(name='jason',password=123)
# 方式三（了解）:
l = [
['name','jason'],
['password',123]
]
d3 = dict(l)
d4 = dict([('a',1),('b',2),('c',3)])
print(d4) # {'a': 1, 'b': 2, 'c': 3}
# 按key取值、改值、添加值
d = {'name': 'jason','password': '123'}
d['name'] = 'egon'
print(d['name']) # egon,key不存在则报错,建议用get()
d3['age'] = 18 # 赋值语句当key不存在时,会自动新增一个键值对(******)
print(d3) # {'name': 'egon','password': '123','age': 18},id不变
# 删除
d = {'name': 'jason','password': '123'}
del d['name']
print(d) # {'password': '123'}
d = {'name': 'jason','password': '123'}
d.pop('name')
print(d) # {'password': '123'}
d = {'name': 'jason','password': '123'}
print(d.pop('name')) # jason 弹出仅仅是value
print(d.pop('age')) # 当键不存在的时候直接报错
d = {'name': 'jason','password': '123'}
d.clear()
print(d) # {}
内置方法
# 1. 键keys(),值values(),键值对items()
d = {'name': 'jason','password': 123}
print(d.keys()) # dict_keys(['name', 'password'])
print(d.values()) # dict_values(['jason', 123])
print(d.items()) # dict_items([('name', 'jason'), ('password', 123)])
# 2. get() 根据key获取value（*****）
d = {'name': 'jason','pwd': 123}
print(d['age']) # key不存在则报错
print(d.get('name')) # jason
print(d.get('age')) # None 当字典的key不存在不报错,返回None
print(d1.get('name','key不存在')) # jason
print(d1.get('age','key不存在')) # key不存在 get可以传第二个参数,当key不存在时,返回第二个参数
# 3. formkeys() 快速创建一个字典
l = ['name','password','age']
print(dict.fromkeys(l,None)) # {'name': None,'password': None,'age': None}
print(dict.fromkeys(l,123)) # {'name': 123,'password': 123,'age': 123}
d = dict.fromkeys(l,[]) # 此时name、password、age指向的是同一个列表,当name的列表值改变时,password和age也会跟着改变
print(d) # {'name': [],'password': [],'age': []}
d['name'].append('jll')
print(d) # {'name': ['jll'],'password': ['jll'],'age': ['jll']}
# 4. update() key存在则修改,不存在则新增
d = {'name': 'jason','age': 18}
d.update({'age': 28,'hobby': 'study'})
print(d) # {'name': 'jason', 'age': 28, 'hobby': 'study'}
集合（可变 无序）
# 作用: 去重,关系运算
# 集合是可变类型,但每个元素必须是不可变类型（整型、浮点型、字符串、布尔、元组）
# 没有重复的元素
# 定义:
s = {1,2,3,4,5} # s = set({1,2,3,4,5}),set括号内必须是支持for循环的数据类型
print(set('hello')) # {'h','e','l','l','o'}
x = {} # <class 'dict'> 仅仅只写一个大括号,python默认将它当做字典类型
s1 = set() # 在定义空集合时只能用关键字set
内置方法
# 1. add() 添加元素
s = {1,2,3}
s.add(666)
print(s) # {1,2,3,666}
s.add((11,22))
print(s) # {1,2,3,(11,22),666} 将容器类型也当成一个元素传入
# 2. remove() 删除,不存在则报错
s = {1,2,3}
print(s.remove(1))
print(s) # {2,3}
# 3. discard() 删除,不存在不报错
s = {1,2,3}
s.discard(888)
print(s) # {1,2,3}
共有使用和方法
# for循环
#（字符串、列表、元祖、字典（循环的是key））
for i in 'jason':
print(i)
# 按索引取值,若为可变类型即可以存(正向取+反向取)
#（字符串、列表、元祖）
s = 'hello big baby~'
print(s[0],s[-1],s[-2]) # h ~ y
l = [1,2,3,4]
l[-1] = 69
print(l) # [1,2,3,69]
# 切片(顾头不顾尾,步长为负数代表从右往左切)
#（字符串、列表、元祖）
s = 'hello big baby~'
print(s[0: 5]) # hello
print(s[0: 10: 1]) # hello big,步长不写默认是1
print(s[0: 10: 2]) # hlobg,步长表示隔几个取一个
print(s[0: 5: -1]) # 没有值
print(s[5: 0: -1]) # 空格olle,骨头不顾尾
print(s[-1: -10: -1]) #~ybab gib
print(s[0: : ]) # hello big baby~ l[0: : ]即l[0: 15: 1],即到列表尾部,步长为1
print(l[-1: : -1]) # ~ybab gib olleh 把字符串反过来
# len() 长度
#（字符串、列表、元祖、字典、集合）
print(len('hello big baby~')) # 15
print(len([1,2,3,4])) # 4
# in、not in 成员运算
#（字符串、列表、元祖、字典（只能判断key）、集合）
print('g' in 'egon is dsb and egon is sb') # True
print('jason' not in 'egon is dsb and egon is sb') # True
print(5 in [1,2,3,4]) # False
# del 删除,适用于所有类型,没有返回值
s = 'jll'
del s
l = [11,22,33,44,55]
del l[2]
print(l) # [11,22,44,55]
# enumerate()
# 可用于 字符串、列表、元组、字典
d = {'name': 'jll', 'age': 18}
for i,j in enumerate(d):
print(i,j)
"""
0 name
1 age
"""
运算符
基本运算
print(10 / 3) # 除,结果保留小数部分
print(10 // 3) # 除,只保留整数部分
print(10 % 3) # 取余数
print(2**3) # 2的三次方
# python对数字的敏感度不是很高(存储的数字不精确)
增量运算
xxx += 1 # xxx = xxx + 1
xxx -= 10 # xxx = xxx - 10
xxx *= 2 # xxx = xxx*2
比较运算
# 比较运算: == != > < >= <=
# 数字之间可以互相比较大小
print(10 != 3.1) # True
# a = 'hello'
# b = 'z'
# print(b > a) # True 拿hello第一个字母h的ASCII码104和z的ASCII码122比较,了解
# ASCII码,A-Z a-z,z对应的数字最大,A对应的数字最小
赋值运算
name = 'jll'
age = 18
链式赋值
a = 100
b = a
c = b
x = y = z = 8000
交叉赋值
# 切换m n对应的值
m = 80
n = 70
# 第一种:
o = m
m = n
n = o
# 第二种: 交叉赋值
m,n = n,m
解压赋值
# 适用于 字符串、列表、字典、元组、集合
l = [1,2,3,4]
a,b,c,d = l # 前面的变量个数与后面的元素个数必须相等
print(a,b,c,d) # 1 2 3 4
a,_,_,b = l # 只把l的第一个和最后一个元素分别赋值给a和b
print(a,d) # 1 4
print(_) # 3
a,*_,b = l # 只把l的第一个和最后一个元素分别赋值给a和b
print(a,b) # 1 4
print(_) # [2,3]
逻辑运算
# 与 或 非 and or not
print( 1 > 0 and 3 > 4) # False and两边必须同时成立,结果才成立
print( 1 > 0 or 1 > 0 and 3 > 4) # True or只要有一边成立即成立,后面的无需再看
print(not 1 > 3) # True 结果取反
标签：11,
jason,
name,
python,
age,
123,
print
From： https://www.cnblogs.com/jlllog/p/17027132.html