python之路-基础篇-第二周

一、Python解释器：

• cpython为默认解释器，由C语言开发，目前使用最为广泛。
• jpython 运行在Java平台上的python解释器，可以直接把Python代码编译成Java字节码执行；与之类似的还有IronPython（.net）
• PyPy解释器，采用JIT技术，对Python代码进行动态编译，所以可以显著提高Python代码的执行速度。

二、推荐一本书：

python源码剖析

三、字符编码：

• 起初，ASCII码，使用一个字节，8位，表示所有内容：256种字符。
  表示数字1：00000001
• 后来，万国码，unicode，至少2个字节（16位）：65536
  表示数字1：0000000000000001
• 再后来，utf-8，对万国码进行按类压缩，优化存放空间
  数字1：00000001，8位
  汉字：3个字节
• 在python2.x中存在转换的问题
  unicode -> utf8: encode
  utf8 -> unicode: decode
• python3.x中不需要考虑此问题

四、执行脚本传入参数

使用sys.argv传入参数。

import sys
print(sys.argv)

执行结果：

#比如在脚本中传入三个参数,可是同时传入多个参数：

bogon:day02 felo$ python3 ex.py  argv1 argv2 argv3

['ex.py', 'argv1', 'argv2', 'argv3']

五、缓存

• 数字：-5到257

>>> a = 1

>>> b = 1

>>> id(a), id(b)        #id一致，在缓冲池中

(4297537952, 4297537952)

>>> a = 10000

>>> b = 10000

>>> id(a),id(b)        #id不一致，不在缓冲池中

(4316106256, 4316105936)

>>> 

• 字符串：按某种权重计算，具体的待查。。。

#

>>> a = 'hello'

>>> b = 'hello'

>>> id(a),id(b)

(4367149744, 4367149744)

六、字符串相加与格式化

• 每次字符串相加，都会在内存中开辟新的空间，尽量不用

>>> print("hello\t" + "world.")
hello    world.

• 使用字符串格式化比较好，可能只创建两次，相对来说更优化一些,建议尽量使用此方法

  • %s：格式化字符串
  • %d：格式化数字
  • %f：格式化浮点数

>>> name = 'felo'
>>> print('my name is %s.' % name)
my name is felo.
>>> 
>>> age = 18
>>> print('my name is %s.\nmy age is %d' % (name,age))
my name is felo.
my age is 18
>>> 

七、循环

• for while (foreach)

• break;continue;pass;return;exit

  • break：退出整个循环
  • continue： 退出本次循环
  • pass ：占位
  • return：函数中使用
  • exit：程序退出，可以添加退出返回值

八、python中一切都是对象

对象是基于类创建的，所有的功能都是到类中找的。

老师的博客：http://www.cnblogs.com/wupeiqi/articles/5115190.html

使用type(a)能够找到类型，或类型所在的位置

九、数据类型介绍

1）数字

int的一些内置方法： *long,float也类似

• __abs__方法：求绝对值

• __add__方法：相加

• __divmod__方法：元组方式返回除法结果取整和余数

• __eq__方法：判断是否相等，返回布尔值

• __float__方法：转化为浮点数

• __floatdiv__方法：地板除，与5//6等价

• __init__方法：类的构造方法，在创建对象的时候调用

• __pow__方法：幂

举例：

a = 100
print('divmod 方法：a/7')
print(a.__divmod__(7))

print('\nabs方法：a的绝对值')
print(abs(a))
print(a.__abs__())

print('\nadd方法：a+7')
print(a.__add__(7))
print(a+7)

结果：

divmod 方法：a/7

(14, 2)



abs方法：a的绝对值

100

100



add方法：a+7

107

107

2）字符串

查看类型以及类中成员：

type()：返回类名

dir():返回类成员

#例子：
name = 'felo'
print(type(name))
print(dir(name))

执行结果：

<class 'str'>         #str类型

#str的类成员

['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

几个字符串常见方法：

name = str('eric')
result = name.__contains__('er')                #此方法与in等价
print(result)
print('er' in name)            #in和__contains__一致
#
# ###python2.x中方法，3.x中不存在
# name = 'eric{0}'
# name.__format__('alex')
# print(name)


name = 'eric'
result = name.capitalize()    #首字母大写
print(result)

result = name.casefold()        #所有字符小写
print(result)

result = name.center(20, '*')   #居中显示，其余用*号填充
print(result)

result = name.endswith('x', 0, 3)   #切片判断以‘x’结尾
print(result)

result = name.startswith('e', 1, 3)     #切片判断以‘e’开头
print(result)

name = '理解'
result = name.encode('gbk')         #编码为gbk格式,默认是utf-8
print(result)

执行结果：

True

True

Eric

eric

********eric********

False

False

b'\xc0\xed\xbd\xe2'

另外一些方法：

name = 'a\tlex'
result = name.expandtabs()      #将TAB转换成空格，默认8个
print(result)
#可以将脚本转化，这样就不会因为空格或者TAB的原因导致脚本不能执行
执行结果：（只有7个空格，不知道为啥？）
a       lex

name = 'alex'
result = name.find('ex')     #返回找到的位置，没找到就返回-1
result2 = name.find('b')
print(result,result2)
执行结果：
2 -1

name = 'alex'
result = name.index('ex')   #返回找到的位置，没找到返回错误
print(result)
result2 = name.index('b')
print(result2)
执行结果：
Traceback (most recent call last)
File "C:/Users/yangfl/PycharmProjects/test/h.py", line 6, in <module>
 result2 = name.index('b')
ValueError: substring not found
2

name = 'alex {0} as {1}'
result = name.format('sb', 'eric')      #字符串拼接
print(result)
执行结果：
alex sb as eric

name = 'alex {name} as {id}'
result = name.format(name='sb', id='eric')      #字符串拼接
print(result)
执行结果：
alex sb as eric

li = ['s', 'b', 'a', 'l', 'e', 'x']
result = '_'.join(li)       #将序列连接起来，使用'_'
print(result)
执行结果：
s_b_a_l_e_x

name = 'alex'
result = name.ljust(10, '_')    #居左，其余均以"_"填充
result2 = name.rjust(10, '_')   #居右，其余均以"_"填充
print(result)
print(result2)

执行结果：
alex______
______alex

name = ' alex '
result = name.rstrip()      #删除右边空格
result2 = name.lstrip()     #删除左边空格
result3 = name.strip()      #删除两边空格
print(result)
print(result2)
print(result3)

执行结果：
   alex
alex   
alex

# name.lstrip() #删除左空格
# name.rstrip()
# name.maketrans() #有空试下

name = 'alexissb'
result = name.partition('is')       #字符串分成三个部分
print(result)

result = name.replace('a', 'o', 1)     #替换,第三个参数为替换的个数
print(result)

# name.rfind()
# name.rindex()
# name.rpartition()

result = name.rsplit('i')        #这两个没什么区别，不用在意
print(result)
result = name.split('i')
print(result)

3）列表

列表是python中最为灵活的有序集合类型：

• 任意对象的有序集合
• 可以收集其他任意对象，而且按照由左至右的顺序排列
• 通过偏移读取整
  • 与字符串类似
• 可变长度，异构以及任意嵌套
• 长度可变
• 能够包含数字，字符串等
• 属于可变序列的分类
• 可在原序列操作删除、索引赋值等
• 对象引用数组
• 在标准的python解释器中，列表就是C数组而不是链接结构。

列表中常用方法：（列表类中的常用成员）

• 切片操作：

li1 = [1, 2, 3, 4]
print(li1[1:2])  #大于等于1，小于2号索引
print(li1[:2])   #小于2号索引
print(li1[1:])   #大于1号索引
print(li1[0:3:2])    #大于等于0，小于3，相隔2
print(li1[:-1])  #-1之前

执行结果：
[2]
[1, 2]
[2, 3, 4]
[1, 3]
[1, 2, 3]

li1 =[11, 11, 22, 33]
li1.append(44)
print(li1)

li1.clear()
print(li1)


li1 = [11, 11, 22, 33]
result = li1.pop(3)      #按下标删除
print(result)

li1 = [11,11,22,33]
li1.remove(11)    #按值删除，默认删除第一个
print(li1)

li1 = [11,11,22,33]
li1.reverse()       #翻转
print(li1)

执行结果：

[11, 11, 22, 33, 44]

[]

33

[11, 22, 33]

[33, 22, 11, 11]

4）元组

tu = (11, 22, 34,)
li = list(tu)
print(tu)
print(li)

#元组中就两个成员需要注意
# tu.count()

# tu.index()

5）字典

#dic = {'k1':'v1','k2':'v2'}
dic = dict(k1='v1', k2='v2')

new_dic = dic.fromkeys(['k1', 'k2'], 'v1000')
print(new_dic)

print(dic['k1'])
print(dic['k2'])
#print(dic['k3']) #报错
print(dic.get('k3'))
print(dic.get('k3', 'alex'))        #'k3'不存在的时候使用'alex'

dic = dict(k1='v1', k2='v2')
dic.pop('k1')           #指定key
print(dic)

dic = dict(k1='v1', k2='v2')
dic.popitem()       #无序的
print(dic)

dic['k3'] = 123
dic.setdefault('k4')        #默认值None
print(dic)

dic = dict(k1='v1', k2='v2')
dic.update({'k3':123})
print(dic)

执行结果：
{'k1': 'v1000', 'k2': 'v1000'}
v1
v2
None
alex
{'k2': 'v2'}
{'k1': 'v1'}
{'k4': None, 'k3': 123, 'k1': 'v1'}
{'k2': 'v2', 'k3': 123, 'k1': 'v1'}

举个小例子，将列表中小于66的数字和大于等于66的数字分成两部分，并将他们存放到字典中。
这几个数是：11, 22, 33, 44, 55, 66, 77, 88, 99, 90

li1 = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90, ]
dic = {}

for i in li1:
    if i > 66:
        if 'k1' in dic.keys():
            dic['k1'].append(i)    #dic中key存在，value列表后追加i
        else:
            dic['k1'] = [i, ]    #dic中key不存在，新建一个，并将i做成列表赋值给这个key
    else:
        if 'k2' in dic.keys():
            dic['k2'].append(i)
        else:
            dic['k2'] = [i, ]

print(dic)