python设置内存限制 windows python内存上限

一、运算符
in
'helo' in 'adfwadbadfafsdfsd'
'li' in ['li','ok']
二、基本的数据类型
int
a.创建方式
n1 = 123 #根据int 类，创建了一个对象
n2 = int(123) #根据int 类，创建了一个对象 (内存使用此种方式，只要在类(int)后面加了括号就会自动调用_init_这个)
特有的功能在：
int类
功能1
功能2
功能3
_init_ (初始化,带下划线的可以先不看)
如： a = 123
a => int =>_int_(123)
b.int 内部优化
n1=123
n2=n1 这两种情况共用一个内存地址
s = '123alex' #只有包含数字时，才能转换
m=int(s)   报错
n1=123
n2=123这两种情况共用一个内存地址(这是python内部进行优化的-5~257)
+++++++++++++++++两份内存+++++++++++++++++++++++
-5~257
n1=123
n2=123
else:
n1=1234
n2=1234 这两种情况用两个内存地址，因为超出了-5~257范围
====> id(对象的内存地址 = id (对象或过对象的变量名))
查看对象的内存地址
查看内存地址：id (变量名)
查看字符串、数组长度：len(字符串、数组)
如 ： id(n1)
c、长度限制
用int，超出了范围
32位系统 -2**31 ~ 2**31-1
64位系统-2*63 ~ 2**63-1
long
长度限制 long类型是Python int类型不够用的时候自动进行转换的，不需要人员干涉
long类型的长度是根据你的电脑配置来决定的，直到把你的内存耗光为止
如：9223372036854775808L L 表示long类型
123 表示int 类型 当长度不够是自动转换成long类型
三、字符串类型 str
a、创建方式
s1 = 'alex'
s1= str('alex')
s1 =str() 相当于 s1 ='' #创建空字符串
无参数，就是创建空字符串
一个参数，就是创建普通字符串
两个参数，int(字节，编码)=====》
a=123
m=str(a)# 将数字转化成字符串
b、特有功能 常用的部分功能
s1.strip() #两端去除空格
s1.startswith() #以..开头
s1.endswith() #以..结尾
s1.find() #找子序列 '12','H'
s1.replace() #将字符串中的某子序列替换成指定的值
s1.upper() #变大写
s1.lower() #变小写
s1.is.. #是什么什么吗
C、公共功能
索引：只能取出一个元素
切片：取出多个元素
如：
#!/usr/bin/env python
#-*- coding:utf-8 -*-
s2 = str('alex')
print (s2)
a1 = s2[0] #只提取一个元素 用索引
a2 = s2[0:3] #提取多个元素 用切片
print (a1)
print (a2)
len:
len ('李璐') 2.7是按照字节来算的
len ('李璐') 3.5是按照字符来算的
for:
py3.5 ==》循环的全是按照字符来进行的
py2.7 ==》循环的全是按照字节来进行的
注意：
UTF-8 编码,一个汉子，3个字节、 一个字节8位   0101010101
gbk编码的 一个汉子 两个字节
案列如下： 在python3.5 下运行
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#UTF-8 编码,一个汉子，3个字节 一个字节8位 0101010101
#gbk编码的 一个汉子 两个字节
#在python3.5 下运行
name = 'lilu'
for x in name:
print(x)
name='李璐'
#name = 'lilu'
for x in name:
print(x)
#在python3.5的输出结果如下： 因为循环的全是按照字符来进行的
# l
# i
# l
# u
# 李
# 璐
案列如下： 在python2.7 下运行
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#UTF-8 编码,一个汉子，3个字节 一个字节8位 0101010101
#gbk编码的 一个汉子 两个字节
name = 'lilu'
for x in name:
print(x)
name='李璐'
#name = 'lilu'
for x in name:
print(x)
#在python2.7的输出结果如下： 因为循环的全是按照字节来进行的
# C:\Python27\python.exe C:/Users/Administrator/PycharmProjects/day2/day3/s2_ceshi.py
# l
# i
# l
# u
# �
# �
# �
# �
# �
# �
# 因为UTF-8 编码,一个汉子，3个字节，两个汉子就是6个字节，Python2.7按照字节来循环，因此出现六个乱码
编码、for:
1、python3.5 for 循环的时候，循环的每一个元素是'字符'
2、字符 =》 字节；
bytes_list = bytes ('字符串',encoding = 'utf-8')
utf-8 -》 3字节
gbk -》 2字节
print (bytes_list) #默认每一个字节都是16进制表示
for b in bytes_list:
print (b) #默认每一个字节都是10进制表示
3、10进制的数字 ==》 2进制
len
id
bin(10进制的数字) 案列如下：
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# bin 将数字转换为二进制
b = 10
er_b = bin (b)
print (b,er_b) #10 0b1010
综合案列 一 、如下：
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#UTF-8 编码,一个汉子，3个字节 一个字节8位 0101010101
#gbk编码的 一个汉子 两个字节
name='李璐'
for x in name:
print(x)
bytes_list = bytes(x,encoding='utf-8') # bytes 可以将字符串转换字节 b'\xe6\x9d\x8e'(16进制 ) 转换成了字节
print (bytes_list)
for b in bytes_list:
print (b,bin(b))
#bin 表示转换成二进制
#字节默认是16进制 b'\xe6\x9d\x8e'(16进制 )
#输出每一个字节时是按照10进制进行展示 231 0b11100111
d、bytes和str的转换
综合案列 二 、如下： 字符和字节间相互转化
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#UTF-8 编码,一个汉子，3个字节 一个字节8位 0101010101
#gbk编码的 一个汉子 两个字节
#bytes #字节类型
#str(字节类型，编码) #字符串类型
a = '李璐'
#将字符串转换成字节
b1 = bytes(a,encoding= 'utf-8')
print (b1)
b2 = bytes (a,encoding='gbk')
print (b2)
#将字节转换成字符串
newa1 = str(b1,encoding='utf-8')
print (newa1)
newa2 = str(b2,encoding='gbk')
print (newa2)
#!/usr/bin/env python
#-*- coding:utf-8 -*-
s = 'alex'
s1_bytes = s.encode('utf-8') #编码 encode('utf-8') utf-8 是指定要编码成什么样的编码类型 转换为字节
print(s1_bytes)
s1_str = s1_bytes.decode('utf-8') #转换为字符串
print(s1_str)
s = 'alex'
s1_bytes = s.encode('gbk') #编码 encode('utf-8') utf-8 是指定要编码成什么样的编码类型 转换为字节
print(s1_bytes)
s1_str = s1_bytes.decode('gbk') #转换为字符串
print(s1_str)
总结如下：
凡是遇到 x = str () 或者 m = bytes() 两种情况
创建字符串
转换成字符串 需要知道编码
m = bytes()
创建字节
转换成字节 需要知道编码(要编程什么编码类型的字节)
str()
str类 _init_
四 、 list 列表 元素的'集合',列表  (它是可变元素的集合)
a、创建和转换
1、创建
li = [11,22,33,44]
li = list() (创建了一个空列表)
li = list([11,22,33,44])
2、转换   #字符串，元组，字典 ===》列表
str -> 创建字符串，或者将其他的转换成字符串
list -> 创建列表，将其他元素转换成列表
案列一、如下：字符串转换成列表
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#字符串，元组，字典 ===》列表
#字符串转换成列表
s1 = '李璐'
# for 循环 字符 ===>只要可以进行for循环就是表示可迭代
li = list (s1) #for 循环，将循环的每一个元素，当做列表的元素
#['李','璐']
print (li)
案列二、元组转换成列表
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#元组转换成列表
# # for 循环 字符 ===>只要可以进行for循环就是表示可迭代
t2 = ('alex','laonanhai','seven')
l2 = list(t2)
print (l2)
案列三、字典转换成列表
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#字典转换成列表
dic = {
'k1':'alex',
'k2':'seven'
}
l3 = list(dic)
l4 = list(dic.values())
l5 = list(dic.items())
print (l3)
print (l4)
print (l5)
# C:\Python35\python.exe C:/Users/Administrator/PycharmProjects/day2/day3/s2_ceshi.py
# ['k1', 'k2']
# ['alex', 'seven']
# [('k1', 'alex'), ('k2', 'seven')]
b、列表特有功能
li = [111,22,3]
li.append() #追加
li.clear() #清楚
li.extend() # 扩展，批量增加 ，用另外一个可迭代的对象扩充到自己内部 (str ,list,dict,tuple 这些都可以迭代)
li.reverse() #翻转 自己内部元素翻转
li.insert() #向指定位置插入元素 如：li.insert(1,'x')
#!/usr/bin/env python
#-*- coding:utf-8 -*-
s = 'alex '
s.strip()
new_s = s.strip()
print (s)
print (new_s)
#extend 扩展
li = [111,22,3]
s = '李璐'
print (li)
li.extend(s)
print (li)
c、公共功能
li = ['alex','eric','seven',123]
索引：li[2]
切片：li[2:3]
for
len
如下：
#!/usr/bin/env python
#-*- coding:utf-8 -*-
li = ['alex','eric','seven',123]
print (li[2]) #取出的是字符
print (li[2:3]) #取出的是列表 用切片取出的时候，原来是什么，取出的结果集就是什么(因为li是列表，所以结果集是列表)
da = 'alex'
print (da[0]) #取出的是字符
print (da[0:3]) #取出的是字符 #取出的是字符 用切片取出的时候，原来是什么，取出的结果集就是什么(因为da是字符，所以结果集是字符)
#结果如下：
# seven
# ['seven']
# a
# ale
d、嵌套提取
li = ['alex','eric','seven',123]
li = ['alex',123,{'k1':'v1','k2':{'vv':(11,22,123),'ii':456}}]
思路如下：
li[2]-->{'k1':'v1','k2':{'vv':(11,22,123),'ii':456}}
li[2]['k2'] -->{'vv':(11,22,123),'ii':456}
li[2]['k2']['vv']-->(11,22,123)
li[2]['k2']['vv'][2]-->123
案列如下：
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#取出 (11, 22, 123) 里面的123
li = ['alex', 'eric', 'seven', 123]
li2 = ['alex', 123, {'k1': 'v1', 'k2': {'vv': (11, 22, 123), 'ii': 456}}]
n1 = li2[2] #提取出 {'k1': 'v1', 'k2': {'vv': (11, 22, 123), 'ii': 456}}
n2 = li2[2]['k2'] #提取出 {'vv': (11, 22, 123), 'ii': 456}
n3 = li2[2]['k2']['vv'] #提取出 (11, 22, 123)
n4 = li2[2]['k2']['vv'][2] #最终提取出 123
print (li2)
print (n1)
print (n2)
print (n3)
print (n4)
# li[2] -->{'k1': 'v1', 'k2': {'vv': 123, 'ii': 456}}
# li[2]['k2'] -->{'vv': 123, 'ii': 456}
# li[2]['k2']['vv'] -->(11, 22, 123)
# li[2]['k2']['vv'][2] -->123
list
list()
list 类 _init_
五、元组
a、 创建和转换
t = (11,22,33)
t = tuple ((11,22,33))
t = tuple ([])# 字符串、列表、字典 (接受可迭代的东西)
b、特有方法
count()
index
c、 嵌套 (元组的元素不可修改，但是元素的元素可修改 )
t = (11,22,33)
t = (11,22,['alex',{'k1':'v1'}])
t[2][1]['k1']--->'v1'
d、元组的特性。不可修改，谁不可被修改
元组，儿子不能变
元组，儿子不能变，孙子.....
案列一、如下：
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#元组
#tuple
t = (11,22,['alex',{'k1':'v1'}])
t3 = t[2]
print (t3) #t3是个列表 因为t3是个列表，因此可以追加
t3.append('xxx') #给t3列表追加 'xxx'
print (t)
案列二如下、
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#增加一个 k2:123
t = (11,22,['alex',{'k1':'v1'}])
temp = t[2][1]
temp = t[2][1]['k2']=123 # 方法一
t[2][1].update({'k3':'90'}) #用update方法进行更新 方法二
#temp['k2']=123
print (temp)
print (t)
总结：
一般字符串，执行一个功能，生成一个新内容，原来内容不变
list(列表),tuple(元组),dict(字典)，执行一个功能，自身进行变化
六、字典
1、创建字典的 两种方式
案列一、创建字典的两种方式
#!/usr/bin/env python
#-*- coding:utf-8 -*-
a = {'k3':123} #方法一
a2 = dict(k1=123,qq=456) #方法二print (a)
print (a2)
案列二、列表转换成字典
li = [11,22,33,44]
字典: key :10递加
value：列表的元素
dic = {}
for x ,v in enumrate(li,10):
dic[x]=v
new_dict = dict(enumrate(li,10))
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#列表转换成字典
li = [11,22,33]
new_dict = dict(enumerate(li))
new_dict2 = dict(enumerate(li,10))
print (new_dict)
print (new_dict2)
2、字典内部功能
keys()
values()
items()
pop()
fromkeys的用法  基本上不用
案列如下：
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#fromkeys的用法
dic = {
'k1':123,
'k2':456,
'k4':111
}
#k1,k2，默认值alex fromkeys用来创建字典，直接用dict里面的key,如果没有直接添加，valus全是alex
n = dic.fromkeys(['k1','k2','k3'],'alex')
n2 = dic.fromkeys(['k1','k2','k3'],[]) # 这时k1,k2,k3全部执行的是同一个空列表
print (n)
print (n2)
n2['k1'].append('xxx') #因为k1,k2,k3全部指向同一个列表，所以一个有变化，都会变化
print (n2)
知识点整体回顾
一、回顾之前的内容
1、顶部
解释器
编码
2、编写第一个程序
print ('hello')
print 'world'
3、编码
ascil ->unicode -> gbk,utf-8.....
ascil - 一个字节，8位
Unicode -》 最少2个字节
utf-8 -》 3个字节一个中文，
gbk -> 2个字节一个中文
4、命名规则
首字母不是数字
变量名不能是关键字
变量由 数字、字母、下划线组成
5、 条件
if 条件：
pass
elif 条件：
pass
else:
pass
--注意缩进问题
6、while
while 条件：
pass
continue
break
7、运算符
num = 123
ret = num % 2 #余数
if ret ==0:
偶数
else:
奇数
num = 'alex'
li = ['alex','eric']
if num in li and num.startswit('a'):
print ('zai')
else:
print ('xxx')
8、基本数据类型
int ,整型
n =123
n=int(123) # int类的 _int_
s='123'
m=int(s)
s = '123alex' #只有包含数字时，才能转换
m=int(s)
str 字符串
s = 'abc'
s =str('abc')
a=123
m=str(a)# 将数字转化成字符串
===========================
bytes =>字节类型
str =》字符串
目的：字节=》字符串
b=字节类型
m=str(b,encoding='utf-8')
首字母变大写
去空格
变大小写
替换
是否为数字、字母
开头、结尾
查找
个数
格式化
编码 解码
居中
li = ['alex','sb']
li='_'.join(li)
#li对应的值 alex_sb
list 列表
li = ['alex','jack']
li=list[]
li=list([11,22,33])
公共功能：
索引
切片
for
长度
enumrate
in
del li[0]
del li[0:2]
特有功能：
翻转
排序
追加
插入
索引位置
删除
个数
扩展
清除
元组
T =(11,22,33)
T =tuple(可迭代的对象)
li =[11,22,33,44]
m=tuple(li)
公共功能：
索引
切片
for
长度
enumrate
in
特有功能：
个数
索引位置
元组特性：
儿子不能被修改
字典：
d = {'k1':123,'k2':123}
d2 = {
'k1':123,
'k2':456
}
li = [11,22,33,44]
字典: key :10递加
value：列表的元素
dic = {}
for x ,v in enumrate(li,10):
dic[x]=v
new_dict = dict(enumrate(li,10))
公共功能：
索引：
增加 dic[key] = value
删除 del
for
长度
in
特有功能：
item 项
key 键
value 值
get
has_key =>
xxx in dic.keys()
update
clear
字符串，字节
str
bytes
a = '李杰'
==>gbk编码的字节
b = bytes(a,encoding = 'gbk') type(b)=>bytes
c= str(b,encoding ='gbk')
int 优化机制
a = 123
b = 123
#id(a) 看变量地址
#相同，因为有优化 -5~257
a = 123
b = a
d = {'k1':123}
#给字典增加值的两种方法
d.update ({'k2':123})
d['k2'] =123