Python基础教程-优快云博客

1.python软件安装

2.python基础语法

编码

默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。


有些面试题中会问# -*- coding: cp-1252 -*-    和   # coding: cp-1252   有什么区别，其实是一样的。   

'''
主要作用是标明python文件使用的字符编码方式，让解释器可以正确识别。

官方文档中对这段编码声明用一段正则表达式来声明：\%^.*\?#.*coding[:=]\s*[0-9A-Za-z-_.]\+.*$  

对于这个正则有些有点看不懂，但是大致如下必须有coding:[编码]或者coding=[编码]才行




但是为什么通常用  # -*- coding: cp-1252 -*-  这种方式呢？

答案在PEP-0263里面有所提及，那就是Emacs等编辑器使用这种方式进行编码声明。



相关参考

PEP-0263     #定义python源代码编码

http://www.python.org/dev/peps/pep-0263/

vim语法文件编写总结

http://www.cnblogs.com/kohpoll/archive/2012/08/04/2623483.html





'''

2.注释

单行注释：
        #
多行注释：
        '''

        '''或

        """

        """

3.python基本数据类型

数字类型：整型(int)、浮点型(float)、布尔值(bool)、【复数(complex)如 1 + 2j、 1.1 + 2.2j】
字符串（string）
列表（list）
字典（dict)和集合(set)
元组（tuple）

强制类型转换：python提供了将变量或值从一种类型转换为另一种类型的内置函数。

强制类型转换：

    int：转换为整型，可以通过base参数指示带转换数据的格式
    float：转换为浮点数
    str：转换为字符串
    list：转换为列表，参数必须是可迭代对象(str、tuple、set、dict)
    tuple：转换为元组，使用方法同上
    set：转换为集合，使用方法同上
    dict：转换为字典，参数的内容必须是成对出现的
    
    # 转换为整数
    a = int('123')           
    print(a)
    print(type(a))

    # 转换为浮点数
    b = float('123.456')
    print(b)
    print(type(b))

    # 转换为字符串
    c = str(123)
    print(c, type(c))


# 转换为列表，参数必须是可迭代对象

    # 会将其中的每个字符做为列表中的一个元素
    d = list('hello')

    # 此处会报TypeError错，int不是可迭代对象
    # d = list(123)
    d = list((1,2,3))
    d = list({1,2,3})

    # 只会保留字典的键
    d = list({'name': 'xiaoming', 'age': 20})
    print(d, type(d))

    # 转换为元组
    # e = tuple()
    # 创建空元组
    # e = ()
    e = tuple(['李白', '李商隐', '李贺'])
    print(e, type(e))

    # 转换为集合
    # f = set()
    f = set(['李白', '李商隐', '李贺'])
    print(f, type(f))

    # 转换为字典
    lt = [['name', 'dahua'], ['age', 18]]
    g = dict(lt)
    print(g, type(g))



结果：
123
<class 'int'>
123.456
<class 'float'>
123 <class 'str'>
['name', 'age'] <class 'list'>
('李白', '李商隐', '李贺') <class 'tuple'>
{'李白', '李商隐', '李贺'} <class 'set'>
{'name': 'dahua', 'age': 18} <class 'dict'>

4.运算符

赋值运算符：‘=’，左边只能是变量
算术运算符：‘+’、‘-’、‘*’、‘/’、‘//’、‘%’
复合运算符：+=、-=、*=、/=、//=、%=、**=
关系运算符：<、>、==、<=、>=、!=
逻辑运算符：与（and）、或（or）、非（not）
成员运算符：in、not in 判断一个变量是否在/步子另一个变量中
位运算符（了解）：&(按位与)、|（按位或）、^（按位异或）、~（按位取反）、<<（按位左移）、>>（按位右移）

5.流程控制

顺序结构：就是代码按照从上到下的顺序依次执行，没有语法要求
分支结构：适合解决生活中非此即彼、多重选择问题。if……elif……else
循环结构：while、for……in
1. 循环的嵌套：双重循环，冒泡排序、选择排序

#冒泡排序
lt = [1, 5, 7, 3, 2, 4]

# 计算元素的个数
n = len(lt)
# 外层循环控制圈数
for i in range(n-1):
    for j in range(n-1-i):
        # 不合适，交换数据
        # 此处是升序排序，若想降序需要将 > 改为 <
        if lt[j] > lt[j+1]:
            # 其他语言
            # temp = lt[j]
            # lt[j] = lt[j+1]
            # lt[j+1] = temp
            # python特有
            lt[j], lt[j+1] = lt[j+1], lt[j]

print(lt)

#选择排序
lt = [3, 5, 2, 1, 8, 4]
print(len(lt))
for i in range(len(lt)-1):
    for j in range(i+1, len(lt)):
        if lt[i] > lt[j]:
            lt[i], lt[j] = lt[j], lt[i]
print(lt)

6.函数

函数的优点：解决代码的重复书写问题；可以将功能的实现者和使用者分开，提高开发效率
1. 定义函数的格式：

def 函数名（ [参数列表] ：

函数体

2.匿名函数（lambda）：python允许你定义一种单行的小函数

定义格式：labmda 参数：表达式 lambda 函数默认返回表达式的值。你也可以将其赋值给一个变量。
lambda 函数可以接受任意个参数，包括可选参数，但是表达式只有一个。

例子：g = lambda x, y: x*y

3.闭包函数：外部函数中定义一个内部函数，内部函数中使用外部函数的局部变量，外部函数将内部函数作为返回值返回，此时的内部函数就叫闭包

#闭包
def wai(n):
    def nei():
        return n * n
    return nei


f1 = wai(3)
f2 = wai(2)

print(f1())
print(f2())

4.装饰器：我们想要增加原有函数的功能，但是不想（无法）改变原来的函数

#装饰器=回调函数 + 闭包函数 + 作用域
 装饰器————就是用于拓展原来的函数功能的一种函数
第一种方法:
import time
def deco1(f1):
    def wrapper1(*args,**kwargs):
        start_time = time.time()
        f1(*args,**kwargs)
        end_time = time.time()
        execution_time = (end_time - start_time) *1000
        print("time is %d ms "%execution_time")
    return warpper

@deco1
def f1():
    '''
    计时
    '''
    print("Hello")
    time.sleep(1)
    print("World")

第二种方法:

def deco2(f2):

    def wrapper2(*args,**kwargs):
        print(wrapper2.__doc__)
        return f2()
    return wrapper2


@deco2
def f2():
    '''
    验证
    '''
    print("func")


#运行过程解读:
    #首先 调用 @uter   返回 return inner ，引用inner，(inner是函数体)
	#接着，调用inner(), 打印 "inner.__doc__" , return func() 返回function函数的值
	#最后，None --是因为闭包函数中用了return ，回调函数中没有用return



#引申:
*args：   它接收元组作为位置参数
**kwargs：它接收字典作为位置参数

5.生成器：保存了生成数据的算法，通过在函数中使用关键字yield完成

6.迭代器：能够使用for……in 进行遍历，并且可以通过next函数依次获取元素的对象

判断一个对象是否是迭代器 lt = (i for i in range(10)) ==》print(isinstance(lt, Iterator))

7.高级函数：map、reduce、filter、random

7.高级特性

切边：利用索引范围，对字符串、列表、元祖等等，进行截取操作。

正索引和负索引两部分，如下图所示，以a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]为例：

值：0, 1, 2, 3, 4, 5, 6, 7, 8, 9

正索引：0 1 2 3 4 5 6 7 8 9

负索引:-10 -9 -8 -7 -6 -5 -4 -3 -2 -1

迭代：如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代.
列表生成式：Python内置的非常简单却强大的可以用来创建list的生成式.
生成器(generator)：在Python中，这种一边循环一边计算的机制，称为生成器.

第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator.

我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它.

generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，

而是一个generator.

遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行.

迭代器(Iterator)：可以被next()函数调用并不断返回下一个值的对象称为迭代器.

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

8.高级函数

map()函数接收两个参数，一个是函数，一个是(可迭代对象：str、list、tuple、set、dict)Iterable，

将传入的函数依次作用到序列的每个元素。由于结果是Iterator，因此通过list()函数让它把整个序列都计算出来并返回一个list。

reduce()函数接收两个参数，一个是函数，一个是Iterable，reduce把结果继续和序列的下一个元素做累积计算。

filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

sorted：排序算法 sorted()函数是一个高阶函数，它还可以接收一个key值来实现自定义的排序排序算法， key指定的函数将作用于list的每一个元素上

对字符串排序，是按照ASCII的大小比较的.
现在，我们提出排序应该忽略大小写(传入key值)，按照字母序排序可以传入第三个参数reverse=True;
p = sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)