当前位置: 澳门新濠3559 > 编程 > 正文

感谢廖雪峰老师,输出的字符串是这样拼起来的

时间:2019-11-08 23:18来源:编程
基于廖雪峰的python零基础学习后,自我总结。适用于有一定基础的编程人员,对我而言,则是基于.net已有方面,通过学习,记录自我觉得有用的地方,便于后续回顾。 1、print()函数也可

基于廖雪峰的python零基础学习后,自我总结。适用于有一定基础的编程人员,对我而言,则是基于.net已有方面,通过学习,记录自我觉得有用的地方,便于后续回顾。

1、print()函数也可以接受多个字符串,用逗号“,”隔开,就可以连成一串输出:

图片 1

跟着廖雪峰老师的Python教程学习Python3,遇到需要注意的地方写到这里,方便以后查阅总结,温故知新。感谢廖雪峰老师!

主要以快速定位内容,通过直观代码输入输出结果,展示独有的特性,更直观表现,而不拘禁于理论描述。待以后使用中遇到坑,再来详细阐述。

>>>print('The quick brown fox','jumps over','the lazy dog')

新智元AI技术峰会倒计时3天

基础

  1. Python中不限定数值大小

  2. 除法: / 普通除法,浮点型, // 取整数部分, % 取余

  3. Python提供了==ord()==函数获取字符的整数表示,==chr()==函数把编码转换为对应的字符

  4. Python的字符串类型是str, 以字节为单位的bytes, 用 b'abc' 表示,读取字节流需要用bytes

  5. 编码encode(): 'ABC'.encode('ascii') = b'ABC', '中文'.encode('utf-8')

  6. 解码decode(): b'ABC'.decode('ascii') = 'ABC'

  7. 计算str包含多少个字符,可以用len()函数, len('abc') = 3

  8. 一般加这两行,说明使用python3,编码方式是utf-8

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    
  9. 占位符:%d 整数,%f 浮点数,%s 字符串,%x 十六进制整数,%% 转义 %,%.2f 保留2为小数

  10. list:l = [1, 2, 3, 'a'], 不同类型的元素也可以放到一个list里, 可操作的函数:append() = add(), insert(index, value), extend(list) = addAll(), count() = size(), clear(), copy(), pop(value), remove(index), reverse(), sort() ...

  11. tuple: t = (1, 2, 4), 不可变list, 当有一个元素是 t = (1,) 用 , 区分

  12. 条件判断:if, elif, else

  13. 循环:for x in ...:, while boolean:

  14. 生成序列: range(5), 转换成list/tuple:list/tuple(range(5))

  15. 字典:dict = {'a': 1, 'b': 2}, 相当于Java的Map, dict的key必须是不可变对象, 可操作函数:setdefault(), get(), clear(), copy() ...

  16. 集合:set:s = set([1, 2, 3]) / s = {1, 2, 3}, 相当于Java的Set, add(), remove(), & 交集, | 并集

本章包含,Python基础、函数、高级特性、函数式编程、模块

The quick brown fox jumps over the lazy dog

新智元将于3月27日在北京泰富酒店举办“2019新智元AI技术峰会——智能云?芯世界”,聚焦智能云和AI芯片发展,重塑未来AI世界格局。

函数

Python的内置函数 (注意函数名不要与内置函数重名)

  1. 定义函数:def,空函数:pass

  2. 判断类型:isinstance(x, A_tuple), 判断实例:issubclass(x, A_tuple)

  3. 函数可以返回多个值,但本质上是返回一个tuple!(例子中的 angel=0 表示默认值,必选参数在前,默认参数在后,默认参数必须指向不变对象!)

    import math
    
    def move(x, y, step, angle=0):
        nx = x + step * math.cos(angle)
        ny = y + step * math.sin(angle)
        return nx, ny
    r = move(100, 100, 50, 30)
    print(r)
  1. 可变参数:def calc(*nums): pass, 在参数前加个星号,即表示为可变参数,0-n都可以,如果想传入list 或者 tuple,可以把在变量钱加个星号转换成可变数组:

    nums = [1, 2, 3]
    print(calc(*nums))
    
  2. 关键字函数:**kw : 入参是dict,好处是可以控制参数的传入

  3. 命名关键字参数:def person(name, age, *, city, job):,用星号分隔,后面的视为命名关键字函数,可以有默认值。调用时必须传入keycity=HangZhou

  4. 五种参数类型的定义顺序:必选参数、默认参数、可变参数、命名关键字参数和关键字参数,def f1(a, b, c=0, *args, **kw): pass

  5. 任意函数都可以通过: fun(*args, **kw) 调用,无论参数如何定义,

    • *args是可变参数,args接收的是一个tuple
    • **kw是关键字参数,kw接收的是一个dict
    • 命名的关键字参数是为了限制调用者可以传入的参数名,同时可以提供默认值
    • 定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*,否则定义的将是位置参数

一、Python基础

  Python程序大小写敏感,个人使用sublime编写程序,注意规范使用tab缩进或者空格,否则程序运行会报unexpected error

  字符串转义:用r''表示''内部的字符串默认不转义   

>>> print(r'\t\')
\t\

        用'''...'''的格式表示多行内容

>>> print('''line1
... line2
... line3''')
line1
line2
line3

        Encode & Decode

>>> 'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'xe4xb8xadxe6x96x87'

>>> b'ABC'.decode('ascii')
'ABC'
>>> b'xe4xb8xadxe6x96x87'.decode('utf-8')
'中文'
>>> b'xe4xb8xadxff'.decode('utf-8', errors='ignore')
'中'

      长度:len(str)

      格式化: %s 字符串; %d 整数; %f 浮点数;%x 十六进制整数;%%=>%

>>> print('%2d-%02d' % (3, 1))
 3-01
>>> print('%.2f' % 3.1415926)
3.14、

  布尔值:True,False

  空值:None 

  集合list  和 元组 tuple

classmates = ['Michael', 'Bob', 'Tracy']    集合list  append 添加,pop 删除

classmates = ('Michael', 'Bob', 'Tracy')

>>> classmates[-3]
'Michael'

#只有一个元素tuple 定义加上逗号 ,
>>> t = (1,)
>>> t
(1,)

#“可变的”tuple 内部list改变,实际指向list位置未变
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

 

  条件判断

age = 20
if age >= 6:
    print('teenager')
elif age >= 18:
    print('adult')
else:
    print('kid')

  dic 字典 和 set

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95

#设定默认值
>>> d.get('Thomas', -1)
-1

#删除
>>> d.pop('Bob')
75

#重复元素在set中自动被过滤:  add(key)  remove(key)
>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}

print()会依次打印每个字符串,遇到逗号“,”会输出一个空格,因此,输出的字符串是这样拼起来的:

同时,新智元将现场权威发布若干AI白皮书,聚焦产业链的创新活跃,助力中国在世界级的AI竞争中实现超越。

高级特性

  1. 切片(Slice):L是个list:L[0:3], L[:3] 0 可省略, L[:10:2] 取前10个数,步长为2, L[:] 复制一个L. tuple, str等都可以切片

  2. 迭代:迭代dict的key: for key in d, 迭代dict的value: for value in d.values(), 同时迭代dict: for k, v in d.items(), 字符串也可以迭代,通过isinstance('abc', Iterable) 判断是否可以迭代。

  3. 多个变量也可迭代:for x, y in [(1, 1), (2, 4), (3, 9)]: pring(x, y), Python内置的enumerate函数可以把一个list变成索引-元素对, 这样就可以在for循环中同时迭代索引和元素本身

  4. 列表生成式:写列表生成式时,把要生成的元素x * x放到前面,后面跟for循环, [x * x for x in range(1, 11)], 还可以跟 if 判断,还可再跟 for 循环[m + n for m in 'ABC' for n in 'XYZ'], 注意是方括号,如果是小括号就是生成器

  5. 生成器(generator):如果一个函数定义中包含yield关键字,那么这个函数就不再是一个普通函数,而是一个generator, yield相当于print,但是每遇到yield就会中断
    杨辉三角形:

    def triangles():
        row = [1]
        while True:
            yield row
            row = [1] + [row[i] + row[i + 1] for i in range(0, len(row) - 1)] + [1]
    
    n = 0
    for t in triangles():
        print(t)
        n += 1
        if n == 10:
            break
    
  6. 迭代器:注意区分IterableIterator

    • Iterable: 可直接作用于for循环的
    • Iterator: 可以被next()函数调用并不断返回下一个值的对象,直到没有对象时抛出StopIteration错误

    generator都是 Iterator 对象,但 list,dict,str虽然是 Iterable,却不是Iterator
    使用iter()函数,可以把Iterable变成Iterator。Iterator是一个数据流,惰性计算,所以可以表示无限大的数据流。
    for循环的本质就是不断调用next()函数实现的

二、函数

  函数定义

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x
#返回多个值 return a,b,c

  函数参数

#默认参数必须指向不变对象!
def add_end(L=None):
    if L is None:
        L = []
    L.append('END')
    return L

# *args 可变参数 **关键字参数
def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

>>> f1(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}

# *,d 命名关键字参数
def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)

>>> f2(1, 2, d=99, ext=None)
a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}

#对于任意函数,都可以通过类似func(*args, **kw)的形式调用它,无论它的参数是如何定义的

图片 2

参会二维码:

函数式编程

  1. 高阶函数:变量可以指向函数 f = abs,函数名是什么呢? 函数名其实就是指向函数的变量。编写高阶函数,就是让函数的参数能够接收别的函数。

    def wtf(a, b, f):
    return f(a) + f(b)
    
    print(wtf(-1, 2, abs))
    

    高阶函数举例:

    • map:map(f, Iterable) 接收两个参数,函数和Iterable, map将函数作用于每一个元素,并返回一个Iterator。Iterator是惰性的,可以通过list()把整个结果计算出来,并返回一个list
    • reduce:reduce把一个函数作用在一个序列[x1, x2, x3, ...]上,取前两个元素算出的结果与下一个元素继续计算, 就像这样:reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
    • filter:filter()也接收一个函数和一个序列。filter把函数作用于序列,返回True保该留元素,False丢弃该元素。同样也返回一个Iterator 惰性序列。
      例如序列中的空字符串删掉:
       list(filter(lambda s: s and s.strip(), ['A', '', 'B', None, 'C', '  ']))
       # 结果: ['A', 'B', 'C']
    
    • sorted:对数字,按大小asc排序,对字符串,ASCII码排序, 例如:sorted([36, 5, -12, 9, -21], key=abs),还可以传入func和是否反转:sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
  2. 返回函数:高阶函数除了可以接受函数作为参数外,还可以把函数作为结果值返回。
    像这样:当调用lazy_sum()时,并没有返回结果,而是返回了sum函数(变量),再次调用会返回一个新函数!每次的调用结果互不影响!

    def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum
    

    闭包:返回闭包时牢记的一点就是:返回函数不要引用任何循环变量,或者后续会发生变化的变量。
    因为返回一个函数时,该函数并未执行!所以不要引用可能会变化的变量

  3. 匿名函数:lambda表达式 lambda x: x * x

  4. 装饰器(Decorator):在代码运行期间动态增加功能的方式,称为装饰器。本质上decorator就是一个返回函数的高阶函数。如果需要给decorator传入参数,则需要编写一个返回decorator的高阶函数。一个完整的decorator如下:注意:装饰器不能改变原函数的行为

    import functools
    
    def log(func):
        @functools.wraps(func)  ##@functools.wraps(func) 是为了保证装饰器不会对装饰器函数造成影响
        def wrapper(*args, **kw):
            print('call %s():' % func.__name__)
            return func(*args, **kw)
        return wrapper
    

    带参数的decorator:

    import functools
    
    def log(text):
        def decorator(func):
            @functools.wraps(func)
            def wrapper(*args, **kw):
                print('%s %s():' % (text, func.__name__))
                return func(*args, **kw)
            return wrapper
        return decorator
    

    函数如果没有显示的return,则会return None

  5. 偏函数:functools模块提供的一个功能,例如: int2 = functools.partial(int, base=2) 这样调用int2时,base默认就是2了,不用再传一遍,当然也可以传其他值,更灵活。偏函数可以接收函数对象,*args, **kw这三个参数。

三、高级特性

  切片 substring

>>> L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
>>> L[1:3]  # L[1] L[2]
['Sarah', 'Tracy']

>>> L = list(range(100))

>>> L[-10:]  # L[-10:100] 后10个
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

>>> L[:10:2]  # L[0:10:2] 前10个数,每两个取一个
[0, 2, 4, 6, 8]

>>> L[:]  # L[0:100:1] copy 复制
[0, 1, 2, 3, ..., 99]

 >>> L[::-1]  #相当于 L[-1:-101:-1]  if s<0 then L[-1:-len(L)-1:-1]
 [99, 98, 97, ..., 0]

  迭代 for

>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False

>>> for i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C

  列表生成式

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']

  生成器 yield

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>
# 使用next(g) or for n in g 可迭代对象g

#斐波拉契数
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

  迭代器

>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False

#Iterable。 for 循环迭代
#Iterator。 next 迭代器
# Iterable 转换 Iterator
>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

2、转义字符\可以转义很多字符,比如\n表示换行,\t表示制表符,字符\本身也要转义,所以\\表示的字符就是\,

新智元报道

模块

Python中一个.py文件就是一个模块(module). Python中有包(package)的概念,每个包下必须要有__init__.py文件,用于区分普通目录与Python的包。 __init__.py 也是一个模块,它的模块名是包的名称。 包可以有多级。注意创建的模块名不要与Python自带的模块名冲突,否则无法导入自带模块,比如 sys 模块。

  1. 使用模块:import sys 之后就可以使用 sys 提供的功能了。

    例如 sys.argv , sys的argv变量,用list存储了命令行的所有参数,argv至少有一个元素,就是文件名称。
    其他注意的地方:

    • 任何模块代码的第一个字符串都被视为模块的文档注释
    • 使用author 把模块作者写进去,__author__ = 'DreamYoung'
    • 命令行运行测试:if __name__ = '__main__'
    • 作用域:__xxx__ 是特殊变量,一般不要用这种变量名,模块的文档注释可以用__doc__访问,__xx是private函数或变量,不应该被外部模块直接引用(Python并没有限制),其他函数或变量为public。注意封装与抽象。
  2. 安装第三方模块:通过包管理工具pip完成,由于是Python3,应该使用pip3,比如安装处理图像的工具库Pillow: pip3 install Pillow (Python解释器搜索模块路径放到 sys.path 变量中,如果找不到可以设置下环境变量 PYTHONPATH

    其他常用模块:

    • MySQL的驱动 mysql-connector-python,
    • 科学计算的NumPy库 numpy
    • 生成文本的模板工具 Jinja2

    Python第三方库官方repo

四、函数式编程 

  高阶函数 map/reduce/filter/sorted

#map 传入函数依次作用到序列每个元素,返回Iterator结果集
>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]
# r 为Iterator惰性序列,list() 是整个序列返回

#reduce  reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
>>> from functools import reduce
>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

#map reduce 结合使用
from functools import reduce
DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
def char2num(s):
    return DIGITS[s]
def str2int(s):
    return reduce(lambda x, y: x * 10 + y, map(char2num, s))

#filter filter()把传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留还是丢弃
def not_empty(s):
    return s and s.strip()

list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))
# 结果: ['A', 'B', 'C']

#sorted sorted()函数对list进行排序
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']

  函数返回值 和 闭包

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum
>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function lazy_sum.<locals>.sum at 0x101c6ed90>
>>> f()
25

#典型闭包错误
def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()

>>> f1()
9
>>> f2()
9
>> f3()
9

##返回闭包时牢记一点:返回函数不要引用任何循环变量,或者后续会发生变化的变量

修改后:

def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)立刻被执行,因此i的当前值被传入f()
    return fs

  匿名函数 lambda

>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]
#lambda 不包含return,返回即使return结果

  装饰器

import functools

def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

@log('execute')
def now():
    print('2018-8-13')

>>> now()
execute now():
2018-8-13

  偏函数

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
#相当于下面这样调用
kw = { 'base': 2 }
int('10010', **kw)

如果字符串里面有很多字符都需要转义,就需要加很多\,为了简化,Python还允许用r''表示''内部的字符串默认不转义

来源:Medium

五、模块

  

>>>print('\\\t\\')

编辑:元子,大明

\       \

本文针对零基础读者,不需要具备任何编程基础,通过本文可以对Python有一个比较整体的了解,便于以后的深入学习打下良好基础

>>>print(r'\\\t\\')

本文试图概述Python编程语言的所有关键点,并专注于绝对需要理解的最重要的主题。完全零基础,你不需要具备任何先前的编程知识,并且可以非常快速地掌握所有必需的概念。

\\\t\\

好,接下来我们开始。

3、空值是Python里一个特殊的值,用None表示。None不能理解为0,因为0是有意义的,而None是一个特殊的空值。

  1. Python简介

4、格式化整数和浮点数还可以指定是否补0和整数与小数的位数:

Python是一种解释型语言: 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言

>>>'%2d-%02d' %  (3,1)'

Python是交互式语言:你可以在一个Python提示符 >>> 后直接执行代码

3-01'

Python是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术

>>>'%.2f' % 3.1415926

Python是初学者的语言:Python对初级程序员而言,是一种伟大的语言,它支持广泛的应用程序开发,从简单的文字处理到WWW浏览器再到游戏

'3.14'

  1. 变量、数据类型及作用域

字符串里面的%是一个普通字符怎么办?这个时候就需要转义,用%%来表示一个%

变量来源于数学,是计算机语言中能储存计算结果或能表示值抽象概念。变量可以通过变量名访问。在指令式语言中,变量通常是可变的。而在Python中,变量等同于names。

>>>'growth rate: %d %%' % 7

声明变量和赋值(Python中也称作binding,相比赋值,绑定这个词可能更形象)操作:

'growth rate: 7 %'

Python支持数据类型包括数字、字符串、集合、列表、元组、字典。数字支持整数、小数、浮点。长整型会有一个L的后缀,比如9999999999999L。字符串是被引号包围由数字、字母、下划线组成的一串字符。

5、数据类型检查可以用内置函数isinstance()

程序创建、访问、改变一个变量时,都是在一个保存该变量的空间内进行,这个空间为命名空间,即作用域。Python作用域是静态的,变量被赋值、创建的位置决定了其被访问的范围,即变量作用域由其所在位置决定。Python的作用域一共有4种,分别是:

6、如果你已经把my_abs()的函数定义保存为abstest.py文件了,那么,可以在该文件的当前目录下启动Python解释器,用from abstest import my_abs来导入my_abs()函数,注意abstest是文件名(不含.py扩展名)

L 局部作用域

7、默认情况下,dict迭代的是key。如果要迭代value,可以用for value in d.values(),如果要同时迭代key和value,可以用for k, v in d.items()。

E (Enclosing) 闭包函数外的函数中

8、如何判断一个对象是可迭代对象呢?方法是通过collections模块的Iterable类型判断:

G 全局作用域

>>>fromcollectionsimportIterable

B 内建作用域

>>>isinstance('abc', Iterable)  # str是否可迭代

以L –> E –> G –>B 的规则查找,即:在局部找不到,便会去局部外的局部找,再找不到就会去全局找,再者去内建中找。

True

  1. 运算符

9、Python内置的enumerate函数可以把一个list变成索引-元素对,这样就可以在for循环中同时迭代索引和元素本身:

Python语言支持以下类型的运算符:

>>>fori, valueinenumerate(['A','B','C']):

算术运算符:+;-;*;/;%(取模 - 返回除法的余数);**(幂 - 返回x的y次幂);//(取整除 - 返回商的整数部分,向下取整)

        print(i, value)

比较运算符:==(等于 - 比较对象是否相等);!=(不等于 - 比较两个对象是否不相等);(不等于 - 比较两个对象是否不相等);>(大于 - 返回x是否大于y);=(大于等于- 返回x是否大于等于y);

0A

赋值运算符:=;+=;-=;*=;/=;%=;**=;//=

1B

位运算符:&;|;^;~;>

2C

逻辑运算符:and;or;not

10、在Python中,一边循环一边计算的机制,称为生成器:generator。

成员运算符:in(如果在指定的序列中找到值返回 True,否则返回 False);not in(如果在指定的序列中没有找到值返回 True,否则返回 False)

generator保存的是算法,每次调用next(g),就计算出g的下一个元素的值,直到计算到最后一个元素,没有更多的元素时,抛出StopIteration的错误。

身份运算符:is(判断两个标识符是不是引用自一个对象);is not(判断两个标识符是不是引用自不同对象)

11、函数式编程的一个特点就是,允许把函数本身作为参数传入另一个函数,还允许返回一个函数!

  1. 注释

Python对函数式编程提供部分支持。由于Python允许使用变量,因此,Python不是纯函数式编程语言。

单行注释:

12、一个函数就可以接收另一个函数作为参数,这种函数就称之为高阶函数

多行注释:

  1. Pickling

将对象转换为字符串并将字符串转储到文件中称为酸洗。 反过来被称为unpickling。

  1. 函数

函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。函数能提高应用的模块性,和代码的重复利用率。

定义新函数:

函数调用

查看字符串长度

  1. 参数

定义函数的时候,把参数的名字和位置确定下来,函数的接口定义就完成了。函数的调用者只需知道如何传递正确的参数,以及函数将返回什么样的值即可。

Python参数包括:位置参数;默认参数;可变参数;命名关键字参数;参数组合。

  1. 模块

Python 模块,是一个 Python 文件,以 .py 结尾,包含了 Python 对象定义和Python语句。模块让你能够有逻辑地组织你的 Python 代码段。把相关的代码分配到一个模块里能让你的代码更好用,更易懂。模块能定义函数,类和变量,模块里也能包含可执行的代码。

导入模块:

调用模块中的函数:

从某个模块中导入一个指定的部分到当前命名空间中:

把一个模块的所有内容全都导入到当前的命名空间:

模块与包是任何大型程序的核心,就连Python安装程序本身也是一个包。包是一个有层次的文件目录结构,它定义了由n个模块或n个子包组成的python应用程序执行环境,包含__init__.py文件和其它模块或子包。

从包里调用模块:

PIP是Python的包管理器,未来你将会频繁的用到他:

  1. 条件语句

Python条件语句是通过一条或多条语句的执行结果(True或者False)来决定执行的代码块,也就是连吃瓜群众都知道的if/else语句:

条件语句是可以嵌套的:

  1. 循环语句

循环语句允许我们执行一个语句或语句组多次,一般包含两种类型:While循环和For循环。

While循环,一直循环知道满足某个条件终止:

While循环嵌套:

For循环,一直循环知道次数用尽:

For循环嵌套语法:

循环控制语句可以更改语句执行的顺序。Python支持以下循环控制语句:

break:在语句块执行过程中终止循环,并且跳出整个循环

continue:在语句块执行过程中终止当前循环,跳出该次循环,执行下一次循环

pass:pass是空语句,是为了保持程序结构的完整性

break语法:

  1. 递归

在函数内部,可以调用其他函数。如果一个函数在内部调用自身本身,这个函数就是递归函数。

举个例子,我们来计算阶乘n! = 1 x 2 x 3 x ... x n,用函数factorial表示,可以看出:

factorial = n! = 1 x 2 x 3 x ... x x n = ! x n = factorial x n

所以,factorial可以表示为n x fact,只有n=1时需要特殊处理。

于是,factorial用递归的方式写出来就是:

  1. 框架与栈调用

Python代码载入框架,框架位于栈中。

函数与参数和变量一起载入框架

框架会按照正确的执行顺序依次载入栈中

栈中列出函数的执行步骤,在函数外声明的变量存储在main中

最后入栈的框架将最先执行

如果发生错误,可以使用回溯来获取函数表

14、列表和库

列表

列表是可以保存任何数据类型的值序列的数据结构。它们是可变的。

列表由整数索引。

字典

字典是编程世界中最重要的数据结构之一。它的功能是存储键/值对对象,可以优化数据检索功能。

15.编译和链接

这些特征可用于使用以另一种语言编写的文件,例如C或C ++等

将代码写入文件后,可以将文件放在Modules目录中。

在Setup.local文件中添加一行非常重要,以确保可以加载新创建的文件。

  1. 迭代器

迭代器可以遍历集合,所有迭代器都包含__iter __()和__next __()函数

只需在列表,字典,字符串或集合上执行iter即可。

如果我们在集合中有大量项目,而且不打算一次加载内存中的所有文件,那么迭代器就是很有用的。一些通用迭代器让开发人员能够实现函数式编程语言实例。

17.面向对象的设计:类

Python允许创建自定义类型。由用户定义的类型称为类。这些类可以具有自定义属性和函数。

面向对象的设计允许程序员将其业务模型定义为具有所需属性和功能的对象。

属性也可以引用另一个对象。

Python类可以引用其他类。

Python支持封装,即实例函数和变量。

Python支持继承。

18.面向对象的设计:继承

Python支持对象的继承。因此,对象可以继承其父级对象的函数和属性。

继承的类可以在其函数中包含不同的逻辑。

如果一个类ParentClass有两个子类:SubClass1,SubClass2

因此,两个子类都将包含函数my_function()。

继承可以鼓励代码重用和维护。

一些常见问题指引

我为什么要使用Python?

简单的编码和学习

面向对象编程语言

伟大的分析和ML包

更快地开发并将我的解决方案推向市场

提供内置内存管理功能

提供巨大的社区支持和应用程序

无需编译,因为它是一种解释性语言

动态输入 - 无需声明变量

如何让Python快速运行?

Python是一种高级语言,不适合访问系统级程序或硬件。

此外,Python不适用于跨平台应用程序。事实上,Python是一种动态类型的解释语言,与低级语言相比,它的优化和运行速度较慢。

实现基于C语言的扩展。

使用Spark或Hadoop创建多进程

利用Cython,Numba和PyPy来加速Python代码,或用C语言编写代码,再像在NumPy中那样在Python中公开

现在有哪些常用的IDE?

Spyder,PyCharm。另外,使用各种笔记本电脑, Jupyter

有哪些顶级Python框架和包?

Python有大量必备的包:

PyUnit,PyDoc,SciPy(algebera和数字),Pandas,Sci-Kit学习,Tensorflow,Numpy,BeautifulSoap,Flask,Pyramid,Django,urllib,Tkinter,mock,PyChecker,Pylint

Python和R可以合并吗?

R中编写了大量丰富的统计库

可以使用Rpy2 python包或在Juputer中使用beaker笔记本或IR内核在Python中执行R代码。

有没有办法在运行Python之前捕获错误?

在运行代码之前,我们可以使用PyChecker和PyLink来捕获错误。

参考链接:

{"type":2,"value":"

编辑:编程 本文来源:感谢廖雪峰老师,输出的字符串是这样拼起来的

关键词: