python入门

变量

变量无类型,对象有类型。(by Mark in leaning python)

变量名:仅仅是一些字母或下划线开头的标识符。其它的字符可以是数字,字母,或下划线。Python变量名是大小写敏感的。

变量分类

  • 不可变变量:数字、字符串、元组
  • 可变变量:列表、字典、集合

    所有变量都是对对象的引用,不可变变量值变化时会指向一个新的对象地址
    变量有作用域,当Python遇到一个变量的时候,她会按照如下顺序搜索:Local->Enclosing Locals->Global->Built-in
    当Python创建变量时,默认创建的是local变量。

数字

是不可改变的数据类型(不可变 变量),这意味着改变数字数据类型会分配一个新的对象。 当指定一个值时,数字对象就会被创建。

Python支持四种不同的数字类型,包括int, long, float, complex

序列

序列类型还包括字符串、列表与元组
序列类型有着相同的访问模式:

  • 它的每一个元素可以通过指定一个偏移量的方式得到。
  • 而多个元素可以通过切片操作方式一次得到。

序列类型操作符

连接操作、重复操作与切片操作都是对对象进行浅拷贝

1. 成员关系操作
obj [not] in sequence

2. 连接操作符(+)
sequence1 + sequence2(这个方法并不是最有效的)

对于字符串来说:所有的子字符串放到一个列表或可迭代对象中,然后调用join方法把所有的内容连接在一起节约内存;

 > '-'.join(['1', '2', '3']) > '1-2-3'

对于列表:推荐使用列表类型的extend()方法来把两个或者多个列表对象合并。

 > l = ['1', '2'] > l.extend(['3', '4']) > print l > ['1', '2', '3', '4']

列表的extend方法返回空。

3. 重复操作符(*)
sequence * copies_int
重复操作符返回的对象是对原来对象的浅拷贝扩充。

4. 切片操作符([], [:], [::])
sequence[starting_index:ending_index :step]
表示的范围为[starting_index:ending_index)

Python序列类型中有两种索引方式:

  • 正向索引:一种整数索引,从0到n-1(n为序列长度),0表示第一个元素
  • 反向索引:一种负数体系,从-1到-n,-1表示最后一个元素

例如

> l = ['1', '2']> print l[0] # 1> print l[-2] # 1

因此,将一个序列倒置的方法,可以为

> sequence[::-1]

内建函数

1. 类型转换
这些转换实际上是工厂函数,将对象作为参数,并将其内容()拷贝到新生成的对象中。

  • list(iter) 把可迭代对象 转换为列表

  • str(obj) 把obj对象转换成字符串(对象的字符串表示法)

  • unicode(obj) 把对象转换成Unicode字符串(使用默认编码)

  • tuple(iter) 把一个可迭代对象转换为一个元组对象

2 . 操作

  • enumerate(iter) 接受一个可迭代对象为参数,返回一个enumerate对象(同时可以一个迭代器),该对象生成由iter每个元素的index值和item值组成的元组

  • len(seq) 返回seq的长度

  • max(iter, key=None)或max(arg0, arg1..., key=None) 返回iter或(arg0, arg1,…)中的最大值。如果指定了key,这个key必须是一个可以传给sort()方法的,用于比较的回调函数。

  • min(iter, key=None)或min(arg0, arg1..., key=None) 与max类似

  • reversed(seq) 接受一个序列作为参数,返回一个已逆序访问的迭代器。

  • sorted(iter, func=None, key=None, reverse=False) 接受一个可迭代对象作为参数,返回一个有序的列表;

  • sum(seq, init=0) 返回seq和可选参数init的总和,其效果等同于reduce(operator, add, seq, init)

  • zip([it0, it1, ... itN]) 返回一个列表,其第一个元素是it0, it1, …,这些元素的第一个元素组成一个元组,第二个。。。类推。

>>> l = ['1', '2', '3']>>> zip(l)[('1',), ('2',), ('3',)]>>> zip(l, l)[('1', '1'), ('2', '2'), ('3', '3')]>>> zip(l, l, l)[('1', '1', '1'), ('2', '2', '2'), ('3', '3', '3')]

字符串

格式化操作符(%)

字符串格式化符号如下:
%c %r %s %d %u %o %x %e %f %g %%

原始字符串操作符(r/R)

原始字符串的目的是为了对付那些在字符串中出现的特殊字符。在原始字符串中,所有的字符都是直接按照字面的意思使用,没有转义特殊或不能打印的字符。

>>> '\n''\n'>>> print '\n'>> r'\n''\\n'>>> print r'\n'\n

Unicode字符串(u/U)

Unicode字符串操作符把标准字符串或者是包含Unicode字符的字符串转换成完全地Unicode字符串对象。

u'abc'

字符串输入(raw_input())

>>> user_input = raw_input("Enter your name:")Enter your name: John Doe>>>>>> user_input'John Doe'>>>>>> len(user_input)8

chr、unichr、ord

  • chr()函数用一个范围在range(256)内的(0到255)整型作为参数
  • unichr()与chr类似
  • ord() 以一个字符作为参数
>>> chr(65)'A'>>> ord('a')97>>> unichr(12345)u'\u3039'

字符串常用内建函数

方法描述
str.capitalize()把字符串的第一个字符大写
str.center(width)返回一个原字符居中,并使用空格填充至长度width的新字符串
str.count(substr, beg=0, end = len(str) )返回指定范围内substr在str中出现的次数
str.decode(encoding=UTF-8′, errors=strict)以encoding指定的编码格式解码string,如果出错默认报一个ValueError的异常,除非errors指定的是ingore或replace
str.encode(encoding=UTF-8′, error=stric)以指定格式编码
str.endwith(obj, beg=0, end=len(str))检查指定范围的字符串是否以obj结束。如果是,返回True,否则返回False。
str.expandtabs(tabsize=8)把字符串str中的tab符号转为空格,默认的空格数tabsize是8.
str.find(substr, beg=0, end=len(str))检测str是否包含substr中。如果是,返回开始的索引值,否则返回-1。
str.index(substr, beg=0, end=len(str))与find类似,若没找到则报一个异常。
str.isalnum()至少一个字符,并且所有字符都是字母或数字,则返回True,否则False。
str.isalpha()如果str至少有一个字符并所有字符都是字母,则返回True,否则返回False。
str.isdecimal()如果str只包含十进制数字则返回True,否则返回False
str.isdigit()如果str只包含数字则返回True,否则返回False。
str.islower()如果str至少包含一个字符,并且所有这些字符都是小写,则返回True,否则返回False
str.isspace()如果str只包含空格,则返回True,否则False。
str.isupper()如果str至少包含一个字符,并且所有这些字符都是大写,则返回True,否则返回False。
str.join(seq)以str作为分隔符,将seq中所有的元素(的字符串表示)合并为一个新的字符串。
str.strip()截掉str左右两边的空格。
str.split(str="", num=str.count(substr))以substr为分隔符切片str,如果num有指定值,则仅分隔num个子字符串。
str.ljust(width)左对齐
str.rjust(width)右对齐
str.zfill(width)右对齐,前面填充0

字符串遍历

字符串遍历的方法与列表、元组与集合一样:

  • 直接用for in遍历
for v in string:    print v
  • 用for in + enumerate遍历
for i,v in enumerate(string):    print i,v

字符串的比较

字符比较是指按照字典次序对单个字符或字符串进行比较大小的操作。一般都是以ASCII码值的大小作为字符比较的标准。
常用ASCII码大小:

  • 0-9: 48-57
  • A-Z: 65-90
  • a-z: 97-122

列表

列表也是序列号的数据类型,是能保存任意数量Python对象的灵活容器。
列表可以包含Python的标准类型,也可用用户定义的对象作为自己的元素。
列表可以包含不同的数据类型,可以执行'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'等操作。

创建、访问、更新、添加、删除操作

  • 创建列表:可以使用[]赋值操作来创建,或者通过工厂方法来创建。
>>> aList = [123, 'abc', 4.56, ['inner', 'list'], 7-9j]>>> list('foo')['f', 'o', 'o']

注意:工厂方法与切片方法都是对对象的浅拷贝。

  • 访问列表:切片操作符[]和索引值或索引值范围一起使用
>>> aList[0]123>>> aList[1:4]['abc', 4.56, ['inner', 'list']]>> aList[:3][123, 'abc', 4.56]
  • 更新、添加列表:
    • 更新:通过索引值或索引值范围的方式更新一个或多个元素
>>> aList[0:2] = [12, 'abcd']>>> aList[2] = ['inner', 'list2']
  • 添加:通过 append 方法来追加到列表中去。
  • 删除列表:
    • del语句删除知道索引的元素。
    • remove方法删除对应值的第一个元素。
    • pop方法删除并返回列表中的一个特定元素。
      一般来说,列表对象出了作用域(比如程序结束、函数调用完成等)后会自动析构,但也可以通过del删除。
>>> del aList[1]>>> aList.remove(123)>>> aList.pop() # 删除并返回列表中的最后一个元素>>> del aList

列表操作符

  • 列表比较:使用内建cmp()函数,两个列表的元素分别比较,直到有一方的元素胜出。
  • 列表序列操作符:切片[start:end:step]、成员关系in, not in、连接操作+、重复操作*
  • 列表内建函数:len(), cmp(), max(), min(), sum(), sorted(), reversed(), enumerate(), zip()

元组

  • 元组是一种不可变类型,其可作为字典的Key。
  • 当处理一组对象时,这个组默认是元组类型。

创建元组

与列表的创建相似,只有一个元素的元组需要在分割符里面加一个逗号,用于防止跟普通的分割符混淆。

>>> aTuple = (123, 'abc', 4.56, ['inner', 'tuple'], 7-9j)>>> anotherTuple = (None, 'something to see here')>>> emptiesPossibleTuple = (None, )>>> tuple('abc')('a', 'b', 'c')

访问元组元素

跟列表一样,用方括号作为切片操作[]

更新元组

跟数字、字符串一样,元组为不可变变量,不能更新或改变元组的元素

删除元组

不可能,除非重建

内建函数

与列表一样

不可变性对元组带来的影响

  • 切片操作不能作为左值进行赋值
  • 字典的键值必须是可Hash的对象,元组变量符合这个标准

映射与集合类型

映射类型:字典

  • 字典是Python语言中唯一的映射类型。映射类型对象是哈希值(键)和指向的对象(值)是一对多的关系。
  • 字典的键可以是字符串、数值与元组等一切可以hash的对象。
  • 字典中的数据是无序排列的。

创建字典

  • 使用{}
>>> dict1 = {}>>> dict2 = {'name': 'earth', 'port': 80}
  • 使用 dict工厂方法
>>> fdict = dict(['x', 1], ['y', 2])>>> fdict{'y':2, 'x':1}
  • 使用 fromkeys内建函数
>>> ddict = {}.fromkeys(('x', 'y'), -1)>>> ddict{'y': -1, 'x': -1}>>> edict = {}.fromkeys(('foo', 'bar'))>>> edict{'foo': None, 'bar': None}

访问、遍历字典

若访问字典中不存在的键,将产生KeyError错误

  • 判断键是否存在
>>> edict.has_key('foo')True>>> 'foo' in edictTrue
  • 遍历键值
for k in dict1:    print k

或者

for k in dict1.keys():    print k
  • 遍历值
for v in dict1.values():    print v
  • 同时遍历键与值
for k,v in dict1.items():    print k,v

更新字典

若使用不存在的键作为等号左值,则可创建新值

>>> dict2['name'] = 'venus'   # 更新已有条目>>> dict2['port'] = 6969      # 更新已有条目>>> dict2['arch'] = 'suno5'   # 增加新条目

删除字典

del dict2['name'] # 删除键为name的字典dict2.pop('name') # 删除并返回键为'name'的条目dict2.clear()     # 删除dict2中所有的条目del dict2         # 删除整个字典

字典比较(较少用)

字典之间的比较按照如下的顺序:

  • 比较字典的长度
  • 比较字典的键,按照keys()方法返回的顺序
  • 比较字典的值,按照values()方法返回的顺序

字典类型方法

  • dict.fromkeys(seq, val=None)

  • dict.copy() # 返回字典(浅复制)副本

  • dict.update(dict2) # 将字典dict2的键-值对添加到字典dict,重复的键值被覆盖

  • dict.setdefault(key, default=None) # 和方法set()相似,如果字典中不存在key键,由dict[key] = default为它赋值。

  • dict.keys()

  • dict.values()

  • dict.items()

  • dict.clear() # 删除字典中所有元素

  • dict.has_key(key) # True or Flase

  • dict.get(key, default=None) # 对字典中的key,返回value,若不存在,返回default的值

  • dict.pop(key[, default]) # 和方法get()相似,若字典中的key键存在,则删除并返回dict[key],如果key键不存在,且没有给出default的值,引发KeyError异常。

字典相关内建函数

len(), max(), min(), sorted()

对dict1的键进行排序

for k in sorted(dict1):    print k

集合

set由不同元素组成,集合对象是一组无序排列的可哈希的值。

集合有两种类型,可变集合(set)与不可变集合(frozenset).

  • set: 不可哈希,可添加与删除元素。
  • frozenset:可哈希,不可添加与删除元素。

创建

使用工厂方法 set() or frozenset()创建

>>> s = set('cheeseshop')>>> sset(['c', 'e', 'h', 'o', 'p', 's'])>>> frozenset('bookshop')frozenset(['b', 'h', 'k', 'o', 'p', 's'])

访问

因为集合是无序的,所有无切片与索引操作,也没有键用来获得集合中的元素。

可以通过 in、not in以及for来查看集合中的元素

>>> 'k' in s>>> 'k' not in s>>> for i in s:    print i

更新

>>> s.add('z')>>> s.update('abc')

删除

>>> s.remove('z')>>> s -= set('pypi')>>> s.pop()  # 无参数,删除集合中的任何一个对象>>> s.discard(obj) # 删除集合中的obj对象>>> del s

Was this helpful?

0 / 0

发表回复 0