python语言精粹《一》

第一章

    静态语言：需要声明类型。变量不能改变类型！

    动态语言：（也称脚本语言）主要的应用场景都是很短的应用程序（脚本），比如给静态语言编写的程序进行数据预处理。这样的程序通常也统称胶水代码。

    python2和python3最明显的区别是处理Unicode字符的方式。

第二章 python的基本元素

2.1 变量、名字和对象

    python最基本的数据类型：布尔、整数、浮点、字符串

     python里面所有的数据--布尔值、整数、浮点数、字符串，甚至大型的数据结构、函数以及程序--都是以对象（object）的形式存在的。

     对象有不同的类型，如布尔型和整形，类型决定可可以对他进行的操作。

     对象的类型决定了它装着的数据是允许修改的变量还是不可修改的常量。

    python是强类型的，你永远不能修改一个已有对象的类型。名字是对对象的引用，而不是对象本身。

2.2 数字

     #数字和运算符中间最好有一个空格。（并不是强制的，仅仅是便于阅读）

    “/”：用来执行浮点除法（整形相除，总得到的是浮点数字）【{15/5=3.0}】

    “//”：整数运算（根据被除数和除数的类型决定商的类型）【{4.5//1.5=3.0}{4//1.5=2.0}{17//6=2}】

>>>divmod(9,5)
(1,4)
#9除以5：同时的到“余数”和“商”

     类型转化：

         int（）   将其他的python数据类型转换为整数。（如果字符串中有不能被识别为数字的将抛出异常）

         int（）   可以接受浮点数或由数字组成的字符串，但是无法接受包含小数点或指数的字符串。

         float（）实用性较高（基本上符合数字规范都可以）

2.3 字符串

     字符串型：是python的序列类型，本质是字符序列。

     python字符串是不可改变的，不可修改的。但是可以将字符串的一部分复制到新字符串。

    '''三引号或者三双引号也可以创建字符串。多用于创建多行字符串。类似《pre》

>>>str(True)
‘True’

        类型转换：

             str（）：当你调用print（）或者进行字符串差值，python内部会自动使用str（）将非字符串对象转换为字符串

>>>a='Duck.'
>>>b=a
>>>c='Grey Duck'
>>>a + b +c
'Duck.Duck.Grey Duck'
>>>print(a,b,c)
Duck. Duck. Grey Duck 
#print()打印的时候，各个参数之间自动添加空格并在结尾添加换行符

         使用len（）获得长度:其他序列类型都可以使用len（）函数

>>>letters='abcde'
>>>len(letters)
5

#和广义函数不同，有些函数只适用于字符串类型
#split（） ：默认使用空白符来分割
#join（）：先指定粘合用的字符串，然后再指定需要合并的列表。

>>>poem.startwith('All')
True
>>>poem.endwith(',folks')
False
>>>word='the'
>>>poem.find(word)   #第一次出现‘the’的位置
73
>>>poem.rfind(word)  #最后一次出现‘the’的位置
214
>>>poem.count(word)  #'the'总出现了多少次
3
>>>poem.isalnum()    #诗中所有的字符都是字母或者数字吗？（有空格和标点）
False

    由于字符串都是不可改变的，下面的一些操作，只是将操作的结果赋值给另一个新的字符串。

>>>str.strip('.')
>>>str.capitalize()
>>>str.title()
>>>str.upper()
>>>str.lower()
>>>str.swapcase() #str所有字符串大小写转化
>>>str.center(30)
>>>str.ljust(30)
>>>str.rjust(30)
>>>str.replace('a ','a famous',100) #'a'后面有空格的哦，如果没有空格，所有的‘a’都被转换了。
'a famous duck goes into afamous ba ...'

第三章 列表、元组、字典与集合

python字符串，它们本质是字符串组成的序列。除了字符串之外，python还有两种序列结构：列表和元组

列表结构：由任意元素组成的序列。

3.1列表和元祖tuple[tapull/toopull]

    除了字符串之外，python还有两种序列结构：列表和元组

     元组是不可变的， 列表是可变的。（字符串不可变）

3.2列表

• 使用 [ ] 或 list（）创建列表/（还有一种是列表推导创建列表）

#如果你仅仅想记录一些不相同的值，而不在乎它们之间的顺序关系，集合（set）是一个很好的选择。

• 使用list（）将其他数据类型转成列表

#元组转化为列表
>>>a_tuple=('ready','fire','aim')
>>>list(a_tuple)
['ready','fire','aim']
#split（）将字符串分割为列表
>>>birthday='1/6/1952'
>>>birthday.split('/')
['1','6','1952']  #是字符非数字

• 使用【offset】获取列表元素、修改列表元素
• 指定范围并使用切片提取元素

#使用切片巧妙的实现的列表的逆序
>>>mar=['gr','ch','ha']
>>>mar[::-1]
['ha','ch','gr']
#从尾部开始提取
>>>mar[::-2]
['ha','gr']

• 使用extend（）或者 += 合并列表

>>>mar = ['gr','ch','ha']
>>>others = ['gu','ka']
>>>mar.extend(others)
>>>mar                      #看看，mar已经被改变了
['gr','ch','ha','gu','ka']

>>>mar = ['gr','ch','ha']
>>>others = ['gu','ka']
>>>mar += others
>>>mar
['gr','ch','ha','gu','ka']

• append（）将单独元素添加到尾部

>>>mar = ['gr','ch','ha']
>>>mar.append('ze')
>>>mar
['gr','ch','ha','ze']

• insert(  )将单独元素插入指定位置

>>>>>>mar = ['gr','ch','ha','za']
>>>mar.insert(3,'gu')
>>>mar
['gr','ch','ha','gu','za']

• 使用 del（）删除指定位置的元素

>>>del mar[-1]

• 使用remove（）删除具有指定值的元素

>>>mar.remove(ha)

• 使用 pop（）获取并删除指定位置的元素

#使用 append（）添加元素到尾部，并通过 pop（）从尾部删除，实现了LIFO（后进先出）队列的数据结构：栈（stack）。
#使用 append（）添加元素到尾部，并通过 pop（0）从头部删除，实现了FIFO（先进先出）队列的数据结构：队列。

• 其他

# .index() 查询特定值的元素位置
>>>mar=['gr','ch','ha']
>>>mar.index('ch')
1
# 使用 in 判断值是否存在
>>>'ch' in mar
True
#使用 .count（）记录特定值出现的次数
>>>mar.count('ch')
1

• 使用 join（）转换为字符串

            join（）实际上是一个字符串的方法。输出也是一个字符串。

            join（）函数参数是字符串或者其他可迭代的包含字符串的序列（如上面使用的字符串列表）

>>>friends=['ha','he','ro']
>>>sep='*'
>>>joined = sep.join(friends)
>>>joined
'ha*he*ro'

• 使用sort（）重新排列元素

            sort（）     对原列表进行排列，改变原列表内容。

            sorted（） 返回排好序的列表副本，原列表内容不变。

        ||__默认排序是升序，通过添加参数reverse=True改变为降序排列。

>>>mar = ['gr','ch','ha']
>>>sorted_mar = sorted(mar)
>>>sorted_mar                #这是一个副本，并不会改变原始‘mar’列表的内容
['ch','gr','ha']
>>>mar
['gr','ch','ha']
>>>mar.sort()
>>>mar
['ch','gr','ha']

• 使用 ‘=’ 赋值，使用 copy（）复制

         ||__将一个列表的值复制到另一个新的列表中：

             列表copy（）函数

             list（） 转换函数

             列表分片 [ : ]

>>>a = [1,2,3]
>>>b = a.copy()
>>>c = list(a)
>>>d = a[:]

         ||__  '='  赋值

#  b和a实际上是指向同一个对象
>>>a = [1,2,3]
>>>b = a
>>>a[0] = 'surprise'
>>>b
['surprise',2,3]

3.3 元组

• 使用（）创建元组

             创建一个或者多个元素的元组时，它的最后一个元素后面的逗号可以省略。

             定义元组真正靠的是每个元素的后缀逗号，并不一定必须加上一对括号。

             可以一次性将元组赋值给多个变量。

             tuple( )函数可以用其他类型的数据来创建元组。

>>>mar = 'gr','ch','ha'     #元组声明
>>>mar
('gr','ch','ha')
>>>a,b,c = mar              #元组解包
>>>a
'gr'
>>>b
'ch'

# 可以利用元组在一条语句中对多个变量的值进行交换，而不需要借助临时变量
>>>pas  = '值_pas'
>>>ice  = '值_ice'
>>>pas,ice = ice,pas
>>>pas
'值_ice'
>>>ice
'值_pas'

• 元组和列表

            ||__ 很多地方可以用元组代替列表，但是元组的方法相对来说少一些，元组没有append（）和insert（）等方法，因为元组不能改变。

                ||__函数的参数是以元组的方式传递的

3.4 字典

         在实际编程中，更多场合用到的是列表、字典。

        字典是可变的。

•   使用  { } 创建字典

             python允许在列表、字典或元组的最后一个元素后添加逗号

• 使用dict（）转换为字典

>>>lot = [('a','b'),('c','d'),('e','f')]
>>>dict(lot)
{'a':'b','c':'d','e':'f'}
>>>los = ['ab','cd','ef']
>>>dict(los)
>>>los
{'a':'b','c':'d','e':'f'}

• update( ) 合并字典

#新归入字典的值会取代原有的值
>>>first = {'a':1,'b':2}
>>>second = {'b':'plat'}
>>>first.update(second)
>>>first
{'b':'plat','a':1}

 

• del                               【  del first['a']  】
• clear(  )                         【  first.clear( )  】= 【first = { }】
• in                                   判断某一键是否存在于一个字典中
• get（）                          通过指定字典键，获得对应的值（可增加默认值选项）

>>>first.get('a')
1
>>>first.get('c','无此字典项')    ## 下面是解释器返回来的，自定义的默认值
'无此字典项'

• 使用 keys（） 获取所有的键

#

•  

转载于:https://my.oschina.net/woailuo/blog/811579