精华内容
下载资源
问答
  • 函数(上)1. 函数简介2. 函数参数2.1 形参和实参2.2 函数传递方式3. 不定长参数4. 参数解包 1. 函数简介 ...  函数名必须符合标识符规范(可以包含字母、数字、下划线但是能以数字开...

    1. 函数简介

      函数也是一个 对象
      函数用来保存一些可执行的代码,并且可以在需要时,对这些语句进行 多次调用
      函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户自定义函数。

    1.1定义一个函数

      你可以定义一个由自己想要功能的函数,以下是定义函数的 基础规则
       1) 函数代码块以 def 关键词开头,后接 函数标识符名称圆括号 ()
       2) 函数的命名要符合 标识符命名规范
       3) 任何 传入参数自变量 必须放在圆括号中间,圆括号之间可以用于 定义参数;圆括号中的参数与参数之间用 , 进行分隔。
       4) 函数的第一行语句可以 选择性地使用文档字符串,—用于存放函数说明。
       5) 函数内容以冒号后 换行起始,并且要和对应的函数名保持 缩进
       6) return [表达式] 结束函数选择性地返回一个值给调用方不带表达式的 return 相当于返回 None(这一点很重要,在后面“14章 模块的使用”中我会给出一个我当时在测试调用不带 return 的模块函数时不知道为什么返回 None 的案例)。

      Python 定义函数使用 def 关键字,一般格式如下:

    # 语法:
    
    def 函数名([形参1,形参2,形参3....]):
        代码块
    

      默认情况下,参数值参数名称按函数声明 中定义的顺序匹配起来的。

    注意:
      函数名必须符合标识符的规范(可以包含字母、数字、下划线但是不能以数字开头)
      print 是函数对象;print() 是调用函数。

    1.2 操作函数

      让我们使用函数来输出"Hello World!":

    def hello() :
       print("Hello World!")
    
    hello 				# 
    print(hello)  		# <function hello at 0x00000243592BE160>
    hello()				# Hello World!
    

      通过以上实例发现
       1) 函数中保存的代码 不会立即执行,需要 调用函数 代码才会执行;
       2) 调用函数方法 : 函数名x()
       3) 单纯的一个 函数名x 没什么特别的意义,它只是一个 函数对象,它就是一个字符串;函数名后面跟一个 () 的意思是:实现 函数名x 的功能

      

    2. 函数的参数

      接下来我们通过实现 “定义一个函数,函数功能是:求 任意 两个数。” 这个任务要求来理解什么是 函数的参数

      那怎么实现 “定义一个函数,函数功能是:求任意两个数的和。” ?
      首先我们先定义一个 求和函数,案例一:

    def an():
        print(1+3)
    
    an()		# 4
    

      通过上面这个案例我们确定了一个 求和函数 怎么定义的;但上面案例输出的结果并不正式的算 两个数的和,和 任意 完全没哈关系。那接下来,我们通过尝试着 定义两个变量 来试试看能否补充这两点,案例二:

    def an():
        a = 3
        b = 4
        print(a + b)
    
    an()		# 7
    

      虽然最后输出的结果是不一样了,但说实话,第二个案例虽然比第一个案例多了两个变量,而且 print() 的内容也变了;但细琢磨,其实和第一个案例 没啥区别,换汤不换药;就是把两个数先拉出来放在外面,打印出来的函数的计算结果是两个固定变量里面值的和,不能改变的还是不能改变。那我们怎么来实现 任意 这个效果?

      在思考怎么来实现 任意 这个效果前,我们要先确定:在调用函数时,print() 里的变量是 在 定义函数 时候 赋值 呢 还是 在 调用函数 的时候 赋值 呢?这个”求任意两个数的和“的函数希望它实现怎么一个功能呢?
      那么我们首先要理解清晰:计算的两个数 能确定吗?是不是 不能确定。换个思路是不是就是 调用函数的时候赋值。那怎么实现这个 调用函数的时候赋值?这个时候,我们就需要使用到函数的参数。来看案例三:

    def an(a,b):
        # a = 3
        # b = 4
        print(a + b)
    
    an(100,2)		# 102
    

      在定义函数的时候,可以在函数后面的 () 里定义 数量不等形参,多个形参之间使用 , 分隔开。

    2.1 形参和实参

      形参(形式参数) 定义:形参就相当于在函数内部声明了 变量,但是 并不是赋值

    def an(a,b):
        a = None
        b = None
        print(a + b)
    
    an()		# TypeError: an() missing 2 required positional arguments: 'a' and 'b'
    

      实参(实际参数) 指定对应 了函数在 创建时定义形参。在调用函数时必须传递 实参实参将会赋值给对应的形参,简单来说:有几个形参就要有几个实参

      实参与形参之间传递的一些操作:

    def ints(a,b,c,d):
    
        print(a,b,c,d)
    
    ints(1,4,7,5)			# 1 4 7 5
    
    #--------------------------------------------------------
    
    def ints(a,b,c,d):
    
        print(a,b,c,d)
    
    ints(1,4,7,)			# TypeError: ints() missing 1 required positional argument: 'd'
    
    #--------------------------------------------------------
    
    def ints(a,b,c,d):
    
        print(a,b,c,d)
    
    ints(1,4,7,5,8,9)		# TypeError: ints() takes 4 positional arguments but 6 were given
    
    #--------------------------------------------------------
    
    def ints(a,b,*c):
    
        print(a,b,c)
    
    ints(1,4,7,5,8,9)		# 1 4 (7, 5, 8, 9)
    
    #--------------------------------------------------------
    
    def ints(*a,b,c):
    
        print(a,b,c)
    
    ints(1,4,7,5,8,9)		# TypeError: ints() missing 2 required keyword-only arguments: 'b' and 'c'
    
    #--------------------------------------------------------
    
    def ints(**a,b,c):
    
        print(a,b,c)
    
    ints(1,4,7,5,8,9)		# SyntaxError: invalid syntax
    

    2.2 函数的传递方式

      定义形参时,可以为形参指定默认值。指定了默认值以后,如果用户传递了参数则默认值 不会生效。如果用户没有传递,则默认值 会自动生效
      位置参数:位置参数就是将对应位置的实参赋值给对应位置的形参;
      关键字参数 : 关键字参数可以不按照形参定义的顺序去传递,而根据参数名进行传递;
      混合使用位置参数和关键字参数的时候,必须将位置参数写到关键字参数前面去

    def fn(a=10, b=20, c=30):		# 默认值传参
        print('a =', a)
        print('b =', b)
        print('c =', c)
        print('a + b + c =', a + b + c)
    
    fn()
    # a = 10
    # b = 20
    # c = 30
    # a + b + c = 60
    
    fn(40, 60, 80)					# 位置传参
    # a = 40
    # b = 60
    # c = 80
    # a + b + c = 180
    
    fn(b=90, c=80, a=70)			# 关键字传参
    # a = 70
    # b = 90
    # c = 80
    # a + b + c = 240
    
    fn(40, c=60)					# 混合传参
    # a = 40
    # b = 20
    # c = 60
    # a + b + c = 120
    
    fn(c=60, 80)					# 混合传参
    #   File "G:/lianxi/测试.py", line 10
    #     fn(c=60, 80)			# 混合传参
    #              ^
    # SyntaxError: positional argument follows keyword argument
    

    2.3 实参的类型

      计算机数据有很多类型,如:整型(int)、浮点型(float)、字符串类型(str)、列表类型(list)、字典类型(dict)、布尔类型(bool) 等等;那 实参 能传递那些类型呢?不同类型之间的传递又有哪些限制和注意呢?

    1. 传递一个整数(int):
    def fn2(a):
        print('a =',a)
    
    fn2(123)			# a = 123
    
    1. 传递一个变量:
    def fn2(a):
        print('a =',a)
        
    b = 456
    fn2(b)			# a = 456
    
    1. 传递一个 布尔值(bool)
    def fn2(a):
        print('a =' ,a)
    
    b = False
    fn2(b)			# a = False
    
    1. 传递一个 空值(None)
    def fn2(a):
        print('a =' ,a)
    
    b = None
    fn2(b)			# a = None
    
    1. 传递一个 字符串(str)
    def fn2(a):
        print('a =' ,a)
    
    b = 'Python'
    fn2(b)			# a = Python
    
    1. 传递一个 方法(fn)
    def fn(a=10, b=20, c=30):
        print('a =', a)
        print('b =', b)
        print('c =', c)
        print('a + b + c =', a + b + c)
    
    
    def fn2(a):
        print('a =', a)
    
    
    fn2(fn)			# a = <function fn at 0x00000215E875E160>
    				# 记住:<> 的意思是“对象”。
    				# 打印返回的内容解释的意思是:返回对象的类型是一个 function ,这个 function 的名字叫 fn ,这个对象所在的内存位置是 0x00000215E875E160(十六进制地址)
    
    1. 老生常谈,不同的数据类型之间不能进行数据运算;
    def fn2(a,b):
        print(a + b)
    
    
    fn2(1,'2')      # TypeError: unsupported operand type(s) for +: 'int' and 'str'
    
    
    1. 可变对象不可变对象
    def fn1(a):
    
        print('a =', a)
    
    c = 10
    
    fn1(c)				# a = 10
    print('c =', c)		# c = 10
    
    #---------------------------------------------------------
    
    def fn1(a):
        
        a = 40			# 在函数中对形参进行赋值,不会影响到其他的变量。
        print('a =', a)
    
    c = 10
    
    fn1(c)				# a = 40
    print('c =', c)		# c = 10
    
    #---------------------------------------------------------
    
    def fn1(a):
        
        print('a =', a)
    
    c = [1,2,3]
    
    fn1(c)				# a = [1, 2, 3]
    print('c =', c)		# c = [1, 2, 3]
    
    #---------------------------------------------------------
    
    # 一个列表一个对象,当我们通过 形参 去修改对象的时候,将会影响到所有指向该对象的 变量。
    # 改变量,改的只是变量内部的值;改变量 值会变,id不变。
    # 改对象,改的是整个对象的 存储id。改对象 真正的值不会变,id改变。与其说是“改对象”不如说是:基于原先的数据基础新建一个对象。
    
    def fn1(a):
        
        a[0] = 40			# a 是一个列表,a 修改列表中的一个元素,a 修改了一整个对象
       						
        print('a =', a)
    
    c = [1,2,3]
    
    fn1(c)				# a = [40, 2, 3]
    print('c =', c)		# c = [40, 2, 3]
    
    #---------------------------------------------------------
    
    # 如果我们传递的是一个 可变对象 时,而我们又不希望因为函数内部的操作而影响到了函数外部的 可变对象 ,那么我们可以使用 copy() 或 切片 等方法制造可变对象·副本来保持 可变对象 原本的值。
    
    def fn1(a):
        a[0] = 40
        print('a =', a, id(a))
    
    
    c = [1, 2, 3]
    
    fn1(c[:])                   # a = [40, 2, 3] 2272265997376
    fn1(c.copy())               # a = [40, 2, 3] 2272265997376
    print('c =', c, id(c))      # c = [1, 2, 3] 2272265769600
    

      

    3. 不定长参数

      你可能需要 一个函数能处理比创建函数是 声明更多的参数。这个参数叫做 不定长参数,和上述几种参数不同,声明时 不定长参数不会命名。而是在形参前面加一个 * ,这样这个形参可以获取到所有的实参,它会将所有的实参保存到一个元组中。这种方法简称为:装包。

      基本语法如下:

    def fun(形参1, 形参2, *形参3):
       代码块
    

      语法实例:

    def fun(*a):
       print ('a = ',a,type(a))
    
    fun(1,2,3,4,5)		# a =  (1,2,3,4,5) <class 'tuple'>
    

      带 * 号的形参只能有一个,可以和其他参数配合使用

    def fun(a, b, *c):
       print ('a = ',a)
       print ('b = ',b)
       print ('c = ',c)
    
    fun( 70, 60, 50, 40, 30, 20, 10 )
    
    # a =  70
    # b =  60
    # c =  (50, 40, 30, 20, 10)
    
    #--------------------------------------------------------------------------
    
    def fun(*a):
        # 定义一个变量,用来保存结果
        result = 0
        # 遍历元组,并将元组中的元素进行累加
        for x in a:
            result += x
    		# print(result)
        print(result)           # 在循环外打印最后的结果,和在循环内打印结果是不一样的。不理解的自己尝试。
    
    fun(1,2,3,4,5,6,7)			# 28
    

       * 形参只能接受位置参数,不能接受关键字参数

    def ints(*a):
        print('a =',a)
    
    ints(b=8,c=9,d=7)			# TypeError: ints() got an unexpected keyword argument 'b'
    

       最后就是注意了。
        注意1. 带 * 号的参数只能有一个,如果出现多个就会报错:

    def ints(a,*b,*c):
    
        print(a,b,c)
    
    ints(1,4,7,5,8,9)		# SyntaxError: invalid syntax
    

        注意2. 不定长参数不一定都写在最后面,但是要注意带 * 的参数后面的所有参数必须以关键字的形式来传递,否则 带 * 的参数只能做最后一个参数:

    def ints(a,*b,c):
    
        print(a,b,c)
    
    ints(1,4,7,5,8,9)		# TypeError: ints() missing 1 required keyword-only argument: 'c'
    
    #--------------------------------------------------------------------------
    
    def ints(*a,b,c):
    
        print(a,b,c)
    
    ints(1,4,7,5,8,9)		# TypeError: ints() missing 2 required keyword-only arguments: 'b' and 'c'
    
    #----------------------      but      ------------------------------------
    
    def ints(a,*b,c):
    
        print(a,b,c)
    
    ints(1,4,7,5,8,c=9)		# 1 (4, 7, 5, 8) 9
    
    #----------------------      but      ------------------------------------
    
    def ints(*a,b,c):
    
        print(a,b,c)
    
    ints(1,4,7,5,b=8,c=9)		# (1, 4, 7, 5) 8 9
    
    #--------------------------------------------------------------------------
    
    def ints(*a,b,c):
    
        print(a,b,c)
    
    ints(1,4,b=7,5,8,c=9)
    #   File "G:/lianxi/测试.py", line 5
    #     ints(1,4,b=7,5,8,c=9)		#
    #                  ^
    # SyntaxError: positional argument follows keyword argument
    

      还有一种就是参数带两个星号 **基本语法如下:

    def ints(**a):
        print('a =',a,type(a))
    
    ints(b=8,c=9,d=7)			# a = {'b': 8, 'c': 9, 'd': 7} <class 'dict'>
    

      ** 形参可以接收其他的 关键字参数,它会将这些参数统一保存到 字典 当中。字典的 键(key) 就是参数的名字,字典的 值(value) 就是参数的值

      带 ** 的形参只有一个,并且必须写在所有参数的后面。

      总结: *a 处理的是位置参数,**a 处理的是关键字参数。

      最后还有附加一点,声明函数时,参数中星号 * 可以单独出现,例如:

    def f(a,b,*,c):
        return a+b+c
    

      如果单独出现星号 * 后的参数必须用关键字传入。

    def f(a,b,*,c):
        print(a+b+c)
    
    # f(1,2,3)		# TypeError: f() takes 2 positional arguments but 3 were given
    
    f(1,2,c=3)
    

      

    4. 参数的解包

      前面提到过一个词,叫 装包。即然有 装包,那么就一定有 解包 了。接下来我们说一说 参数的解包

    def fn(a,b,c):
        print('a =', a)
        print('b =', b)
        print('c =', c)
    
    # 创建一个元组
    t = (20,30,40)
    
    fn(t)			# TypeError: fn() missing 2 required positional arguments: 'b' and 'c'
    
    #--------------------------------------------------------------------------
    
    def fn(a,b,c):
        print('a =', a)
        print('b =', b)
        print('c =', c)
    
    # 创建一个元组
    t = (20,30,40)
    
    fn(t[0],t[1],t[2])
    # a = 20
    # b = 30
    # c = 40
    
    #--------------------------------------------------------------------------
    
    def fn(a,b,c):
        print('a =', a)
        print('b =', b)
        print('c =', c)
    
    # 创建一个元组
    t = (20,30,40)
    
    fn(*t)
    # a = 20
    # b = 30
    # c = 40
    

      传递实参时,也可以 在序列类型的参数前 添加 * 星号,这样它会 自动 的将序列中元素依次作为参数传递;
      并且添加 * 星号的序列类型的参数中 序列的元素个数 必须和 形参的个数 保持一致。

    def fn(a,b,c):
        print('a =', a)
        print('b =', b)
        print('c =', c)
    
    # 创建一个元组
    t = (20,30,40,50)
    
    fn(*t)			# TypeError: fn() takes 3 positional arguments but 4 were given
    
    #--------------------------------------------------------------------------
    
    def fn(a,b,*c):
        print('a =', a)
        print('b =', b)
        print('c =', c)
    
    # 创建一个元组
    t = (20,30,40,50)
    
    fn(*t)
    # a = 20
    # b = 30
    # c = (40, 50)
    

      除了 *t 对元组的解包外,还有 **d 对字典的解包操作:

    def fn(a,b,c):
        print('a =', a)
        print('b =', b)
        print('c =', c)
    
    # 创建一个字典
    d = {'a':1,'b':2,'c':3}
    
    fn(**d)
    # a = 1
    # b = 2
    # c = 3
    

      老生常谈的解包注意点:添加 ** 星号的序列类型的参数中 字典的键·值对个数 必须和 形参的个数 保持一致。

      

    总结小便条

    本篇文章主要讲了以下几点内容:

    1. 函数简介
       函数也是一个对象。
       函数用来保存一些可执行的代码,并且可以在需要时,对这些语句进行多次调用。
      注意:
       函数名必须符合标识符的规范(可以包含字母、数字、下划线但是不能以数字开头);
       print 是函数对象,而 print() 是调用函数。
    2. 函数的参数
      2.1 形参 和 实参
       形参(形式参数) 定义形参就相当于在函数内部声明了变量,但是并不是赋值;
       实参(实际参数)指定了形参,那么在调用函数时必须传递实参,实参将会赋值给对应的形参,简单来说有几个形参就要有几个实参。
      2.2 函数的传递方式
       定义形参时,可以为形参指定默认值。指定了默认值以后,如果用户传递了参数则默认值不会生效。如果用户没有传递,则默认值就会生效;
       位置参数:位置参数就是将对应位置的实参赋值给对应位置的形参;
       关键字参数 : 关键字参数可以不按照形参定义的顺序去传递,而根据参数名进行传递;
       混合使用位置参数和关键字参数的时候必须将位置参数写到关键字参数前面去。
    3. 不定长参数
       定义函数时,可以在形参前面加一个 * ,这样这个形参可以获取到所有的实参,它会将所有的实参保存到一个元组中。
       带 * 号的形参只能有一个,可以和其他参数配合使用;
        * 形参只能接受位置参数,不能接受关键字参数;
        ** 形参可以接收其他的关键字参数,它会将这些参数统一保存到字典当中。字典的 键(key) 就是参数的名字,字典的 值(value) 就是参数的值;
        ** 形参只有一个,并且必须写在所有参数的后面。
    4. 参数的解包
       传递实参时,也可以在序列类型的参数前添加星号 * 或双星号 ** ,这样它会自动的将序列中元素依次作为参数传递;
       要求序列中的元素的个数必须和形参的个数一致。

      本章回顾暂时就到这了,如果还有点晕,那就把文章里所有引用的案例代码再敲几遍吧。拜拜~

    展开全文
  • 见证Python的核心对象类型,比像C这样的底层语言中的对应部分有更好的灵活性,也更强大。例如,列表和字典省去了在底层语言中为了支持集合和搜索所进行的绝大部分工作。列表是其他对象的有序集合,而字典是通过键而...
       见证Python的核心对象类型,比像C这样的底层语言中的对应部分有更好的灵活性,也更强大。例如,列表和字典省去了在底层语言中为了支持集合和搜索所进行的绝大部分工作。列表是其他对象的有序集合,而字典是通过键而不是位置进行索引的其他对象的集合。字典和列表都能够嵌套,能够根据需要增大或减小,以及可以包含任意类型的对象。此外,它们的内存空间在不再使用后也是自动清理的。
       4个Python核心数据类型的名称:数字、字符串、列表、字典、元组、文件和集合一般被认为是核心对象(数据)类型。类型、None和布尔型有时也被定义在这样的分类中。还有多种数字类型(整数、浮点数等)和多种字符串类型(Python 2.X中的一般字符串和Unicode字符串等)。
       为什么我们把它们称作是“核心”数据类型?
       它们被认作是“核心”数据类型是因为它们是Python语言自身的一部分,并且总是有效的;为了建立其他的对象,通常必须调用被导入模块的函数。大多数核心类型都有特定的语法去生成其对象:例如,‘spam’是一个创建字符串的表达式,而且决定了可以被应用的操作的集合。正是因为这一点,核心类型与Python的语法紧密地结合在一起。
       “不可变性”代表了什么,哪三种Python的核心类型被认为是具有不可变性的?
       一个具有“不可变性”的对象是一个在其创建以后不能够被改变的对象。Python中的数字、字符串和元组都属于这个分类。尽管无法就地改变一个不可变的对象,但是你总是可以通过运行一个表达式创建一个新的对象。
      “序列”是什么意思,哪三种Python的核心类型被认为是这个分类中的?
       一个“序列”是一个对位置进行排序的对象的集合。字符串、列表和元组是Python中所有的序列。它们共同拥有一般的序列操作,例如,索引、合并以及分片,但又各自有自己的类型特定的方法调用。
      “映射”是什么意思,哪种Python的核心类型是映射?
       表示将键与相关值相互关联映射的对象。Python的字典是其核心类型集中唯一的映射类型。映射没有从左至右的位置顺序;它们支持通过键获取数据,并包含了类型特定的方法调用。
      “多态”意味着一个操作符(如+)的意义取决于被操作的对象。
    
    展开全文
  • Python学习内容包含Python核心编程、数据库、Web开发、爬虫、运维、人工智能等方向内容,带你畅游Python世界。下面一同来看看吧。 ​  知道你是以下哪种情况,来看看:  1.如果你认准学习Python技术,就是...

      Python学习内容包含什么?如何入门Python行业?Python已经成为一门相当热门的语言,如果想要从事相关的工作,想要了解相关的知识,那么就学习Python吧!Python学习内容包含Python核心编程、数据库、Web开发、爬虫、运维、人工智能等方向的内容,带你畅游Python世界。下面一同来看看吧。

    wpsFD5_tmp.png

      不知道你是以下哪种情况,来看看:

      1.如果你认准学习Python技术,就是为了以后能有个高薪工作,而且你对自己学习Python还很自信,建议可以参加专业的学习。因为你对于工作的迫切需求,你肯定不会像大学那样贪玩不学习,你会极其认真。如果你是这样的情况,别去自学,自学是时间非常多的人才去做的事情,对于迫在眉睫刚毕业的你,不要这样异想天开的又浪费时间。

      2.如果你是那种学着试试看,如果能成功就学,不成功就去随便找个其他工作,那你就自学吧。

      选择要学习的技术和选择要上的大学一样重要,如果选错了,你将来不仅得不到自己喜欢的高薪工作,反而会引来一堆麻烦。Python在约40年前出现以来,已经有数以千计基于这项技术的网站和软件项目,Python因其独有的特点从众多开发语言中脱颖而出,深受世界各地的开发者喜爱。

      Python允许你犯些小错但不会破坏代码,给新手一些信心继续学习。从新手的角度来看,想学一些更容易、更灵活的技术,而Python正是这样的技术。

      总之,Python是一门功能丰富且强大的胶水语言,但只有配合多种库的使用才能让Python的作用发挥到极致。如果你有Python学习的需求,欢迎选择专业的学习。

    展开全文
  • 它涵盖了《Learning Python》的全部主题,但是却更加深入宽泛,所以 这绝单单是一本充分包含核心语言的书籍。如果你只想在市面上购买一本 Python书籍的话,我向你推荐本书。你会享受阅读的,包括它里面会经常幽...
  • 2014年8月20日 《简明Python编程》核心笔记 (1~5章) 昨天和今天两天时间里。把《简明Python编程》这一本书...你将惊喜地发现Python语言是多么地简单,它注重的是怎样解决这个问题而不是编程语言的语法和结构。 P...

    2014年8月20日 《简明Python编程》核心笔记  (1~5章)

    昨天和今天两天时间里。把《简明Python编程》这一本书学完了,包含书上的代码。现把核心笔记记录下来,以便以后复习。

    第一章 简单介绍

    Python语言是少有的一种能够称得上即简单又功能强大的编程语言。

    你将惊喜地发现Python语言是多么地简单,它注重的是怎样解决这个问题而不是编程语言的语法和结构。

    Python的特点:

    1. 简单
    2. 易懂
    3. 免费、开源
    4. 高层语言:高级语言
    5. 可移植性:能够移植在很多平台上。

      包含Linux、Windows、FreeBSD、Macintosh、Solaris、OS/2等等;

    6. 解释性:Python语言写的程序不须要编译成二进制代码。

      在计算机内部。Python解释器把源码转换成称为字节码的中间形式。然后再把它翻译成计算机使用的机器语言并执行。

    7. 面向对象:Python即支持面向过程的编程也支持面向对象的编程。

    8. 可扩展性:假设你须要你的一段关键代码执行得更快或者希望某些算法不公开,你能够把你的部分程序用C或C++编写,然后在你的Python程序中使用它们。
    9. 可嵌入性:你能够把Python嵌入你的C/C++程序。从而向你的程序用户提供脚本功能。
    10. 丰富的库:Python标准库确实非常庞大。它能够帮助你处理各种工作,包含正則表達式、文档生成、单元測试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV文件、password系统、GUI(图形用户界面)、Tk和其它与系统有关的操作。记住。仅仅要安装了Python。全部这些功能都是可用的。除了标准库以外。还有更多高质量库,wxPython、Twisted和Python图像库等等。

    第二章 安装Python

    对于Linux系统,非常可能你已经在你的系统里安装了Python。

    否则,你能够通过你的发行版附带的包管理软件安装Python。对于Windows系统。安装Python就是下载安装程序然后双击它,默认运行,再配置环境变量。

    第三章 最初的步骤

    两种使用Python运的程序的方式——使用交互式的带提示符的解释器或使用源文件。

    1、使用带提示符的解释器

    • 对于Windows用户,仅仅要你正确的设置了PATH变量,你应该能够从命令行启动解释器。

      或者你能够选择使用IDLE程序。IDLE是集成开发环境的缩写。

      点击開始->程序->Python 2.3->IDLE(Python GUI)。Linux用户也能够使用IDLE。

    • >>>是你键入Python语句的提示符。

    2、使用源文件

    • 启动你选择的编辑器,输入以下这段程序,然后把它保存为helloworld.py。

               
       <span style="font-size:18px;">    <span style="color:#006600;">(源文件:code\helloworld.py)</span>
          #!/usr/bin/python
          # Filename : helloworld.py
          print 'Hello World'</span>
    • 请打开shell(Linux终端或者DOS提示符)。然后键入命令python helloworld.py。假设你使用IDLE,请使用菜单Edit->Run Script或者使用键盘快捷方式Ctrl-F5。
    <span style="font-size:18px;">       <span style="color:#009900;">输出:</span>
          $ python helloworld.py
            Hello World </span>

    3、凝视

    • 使用 # 符号标示凝视,从 # 開始,直到一行结束的内容都是凝视。

    4、获取帮助

    • 执行help(object)——这会显示boject类的帮助。

      如,help()str,则会显示str类的帮助信息。

      str类用于保存你的程序使用的各种文本(字符串)。

    • 按q退出帮助。

    第四章 基本概念

    1、字面意义上的常量

    • 一个字面意义上的常量的样例是如同5、1.23、9.25e-3这种数,或者如同'This is a string'、"It'sa string!"这种字符串。

    2、数

    • 在Python中有4种类型的数——整数、长整数、浮点数和复数。

    3、字符串

    • 字符串是 字符的序列 。
    • 字符串的使用:
      • 使用单引號('):你能够用单引號指示字符串,就如同'Quote me on this'这样。全部的空白,即空格和表符都照原样保留。
      • 使用双引號("):与单引號使用同样。

      • 使用三引號('''或"""):利用三引號,你能够指示一个多行的字符串。

      • 转义字符:如果你想要在一个字符串中包括一个单引號('),那么你该怎么指示这个字符串?比如,这字符串是What's your name?

        你肯定不会用'What's your name?

        '来指示它,由于Python会弄不明确这个字符串从何处開始。何处结束。

        所以,你须要指明单引號而不是字符串的结尾。能够通过 转义符 来完毕这个任务。你用\'来指示单引號——注意这个反斜杠。如今你能够把字符串表示为'What\'s your name?'。注意:在一个字符串中,行末的单独一个反斜杠表示字符串在下一行继续,而不是開始一个新的行。

      • 自然字符串:自然字符串通过给字符串加上前缀r或R来指定。

        比如r"Newlines are indicatedby \n"。

      • Unicode字符串:Unicode是书写国际文本的标准方法。

        Python同意你处理Unicode文本——你仅仅须要在字符串前加上前缀u或U。比如,u"This is a Unicode string."。

      • 字符串是不可变的。
      • 按字面意义级连字符串

    4、注意的地方:

    • 在Python中没有专门的char数据类型。
    • 记住。单引號和双引號字符串是全然同样的——它们没有在不论什么方面有不同。
    • 一定要用自然字符串处理正則表達式。

      否则会须要使用非常多的反斜杠。

    5、变量

    6、标识符的命名

    • 标识符的第一个字符必须是字母表中的字母(大写或小写)或者一个下划线(‘ _’)。

    •  标识符名称的其它部分能够由字母(大写或小写)、下划线(‘ _ ’)或数字(0-9)组成。

    • 标识符名称是对大写和小写敏感的。比如,myname和myName不是一个标识符。

      注意前者中的小写n和后者中的大写N。

    7、数据类型

          变量能够处理不同类型的值。称为数据类型。主要的类型是数和字符串

    8、对象

          Python把在程序中用到的不论什么东西都称为 对象

    9、编写Python程序的标准步骤:

    1. 打开你最喜欢的编辑器;
    2. 输入样例中的程序代码;
    3. 用凝视中给出的文件名称把它保存为一个文件。我依照惯例把全部的Python程序都以扩展名.py保存;
    4. 执行解释器命令python program.py或者使用IDLE执行程序。

    注意一下两点:
    • Python使用变量时仅仅须要给它们赋一个值。

      不须要声明或定义数据类型。

    • 假设你想要在一个物理行中使用多于一个逻辑行,那么你须要使用分号(;)来特别地标明这
      种使用方法。分号表示一个逻辑行/语句的结束。

    10、缩进

           空白在Python中是重要的。

    其实行首的空白是重要的。它称为缩进。在逻辑行首的空白(空格和制表符)用来决定逻辑行的缩进层次。从而用来决定语句的分组。

    不要混合使用制表符和空格来缩进。由于这在跨越不同的平台的候。无法正常工作。强烈建议 你在每一个缩进层次使用 单个制表符 或 两个或四个空格 。选择这三种缩进风格之中的一个。

    更加重要的是,选择一种风格,然后一贯地使用它。


    第五章 运算符与表达式

         运算符的功能是完毕某件事,它们由如+这种符号或者其它特定的keyword表示。运算符须要数据来进行运算,这种数据被称为 操作数 。

    1、运算符

         运算符包含+、-、*、/、%、**、//、<<、>>、>>=、<<=、&、|、^、~、<、>、==、!

    =、and、or、not。

    2、运算符优先级:略

    3、表达式     

    <span style="color:#009900;">(源文件:code\expression.py)</span>
         #!/usr/bin/python
         # Filename: expression.py
         length = 5
         breadth = 2
         area = length * breadth
         print 'Area is', area
         print 'Perimeter is', 2 * (length + breadth)
    <pre name="code" class="python"><span style="color:#006600;">输出:</span>
         $ python expression.py
         Area is 10
         Perimeter is 14

    
    

           注意:Python怎样打印“美丽的”输出。

    虽然我们没有在'Area is'和变量area之间指定空格。Python自己主动在那里放了一个空格。这样我们就能够得到一个清晰美丽的输出,而程序也变得更加易读。



    转载于:https://www.cnblogs.com/brucemengbm/p/6884079.html

    展开全文
  • python核心教程:python如何安装pickle

    千次阅读 2019-12-04 16:30:16
    pickle是python语言的一个标准模块,安装python后已包含pickle库,需要单独再安装。 pickle模块实现了基本的数据序列化和反序列化。 通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去,...
  • 不包含很多python模块,因为许多核心模块是用C而不是python编写。 转换后模块为: 内建 元帅 数学 时间 系统 安装 Gpython是Go程序,是一个二进制文件。 从此处下载相关二进制文件: : 或者,如果您已...
  • 在pyobject中没有这样信息,其实这种说法是不对,这个信息虽然显见与pyobject中,但是隐身于pyobject中,占用内存空间大小是对象元信息,这种元信息与对象所属类型密切相关 在typeobject定义中包含了...
  • 这绝单单是一本充分包含核心语言的书籍。如果你只想在市面上购买一本 Python书籍的话,我向你推荐本书。你会享受阅读的,包括它里面会经常幽程序 员的一默。更重要的是,你将学会Python。更更重要的是,你会在...
  • Python核心数据类型——数字一、前言 Python中,数据是以对象形式存在,通俗来讲就是一切皆对象。Python对象主要包含以下几种类型数字;字符串;列表;字典;元组;文件;集合。(以上不是全部但是是主要,...
  • 本文主要涵盖了 Python 编程的核心知识(暂包括标准库及第三方库)。 1. 按顺序依次展示了以下内容的一系列思维导图: 2. 结合这些思维导图主要参考的资料,分享一下我的学习体验,一方面可供初学者参考,另一方面...
  • 这绝单单是一本充分包含核心语言的书籍。如果你只想在市面上购买一本 Python书籍的话,我向你推荐本书。你会享受阅读的,包括它里面会经常幽程序 员的一默。更重要的是,你将学会Python。更更重要的是,你会在...
  • 停学停课,人工智能时代,我选python!文章底部随意打赏作者,获取公号所有整理的案例资源!当前视频讲解Python拥有一个强大的标准库。Python语言的核心包含数字、字符串、列表...
  • 停学停课,人工智能时代,我选python!文章底部随意打赏作者,获取公号所有整理的案例资源!当前视频讲解Python拥有一个强大的标准库。Python语言的核心包含数字、字符串、列表...
  • Python数据科学手册 Python数据科学手册 该存储库包含(免费!)Jupyter笔记本形式的整个。... 本书介绍了使用Python处理数据必可少的核心库:特别是 , , , , 和相关软件包。 假定熟悉Python语言。 如果您
  • 本书是学习Python编程语言的入门书籍。Python是一种很流行的开源编程语言,可以在各种领域... 包含了一些新的章节,主要介绍高级的核心语言话题。  重新组织了一些已有的材料,并且使用新的示例扩展它们以便更清楚。
  • 对于这些类型,Python语言核心定义了文字形式,并对它们语义施加了一些约束,但并未完全定义语义。 (另一方面,语言核心确实定义了语法属性,例如运算符拼写和优先级。) 该库还包含内置函数和异常,这些...
  • Python库介绍

    2017-12-03 14:06:33
    对于这些类型,Python语言核心定义了文字形式,并且在其语义上设置了一些限制,但是没有完全定义语义。(另一方面,语言核心确实定义了句法属性,如运算符拼写和优先级。 该库还包含内置函数和异常 - 可以...
  • 对这些类型来说,Python语言核心定义了书写上格式和位置以及一些语义上约束,但没有完全定义语法(另一方面,语言核心定义了语法特性像拼写和操作优先级) 这个库也包含了内置函数和例外——objects可以需要...
  • 格式:type(类名,父类名称组成元组(父类名,可为空),包含属性字典(名字和值)) 实际工作中基本用到,只了解即可 slots python是动态语言,运行过程中可改变其结构 先看一个例子: class Person(object)...
  • Python学习资料

    2020-10-26 13:53:35
    python核心编程第三版中文版PDF,python进阶教程,包含正则,网络编程,数据库编程,GUI,Django,爬虫,云计算假设等内容,实乃居家旅行,疯狂写码,必备良书! Python是一种复杂但很健全编程语言。它不光具备...
  • Python核心编程第二版全集,含中英文图书、全部代码、答案。中文图书带完整目录,阅读方便 请CSDN网友,下载完,评论同时,要点击评论框上方五角星(共5个五角星),这样你被扣积分就可以返还,还会加一分。...
  • 对于Python这种高级语言来说,开发者需要自己管理和维护内存。Python采用了引用计数机制为主,标记-清除和分代收集两种机制为辅垃圾回收机制。 首先,需要搞清楚变量和对象关系: 变量:通过变量指针引用...
  • python-barcode:借助其他库在 Python 程序中生成条形码。 pygram:类似 Instagram 图像滤镜。 python-qrcode:一个纯 Python 实现二维码生成器。 Quads:基于四叉树计算机艺术。 scikit-image:一个...
  • 停学停课,人工智能时代,我选python!文章底部随意打赏作者,获取公号所有整理的案例资源!当前视频讲解Python拥有一个强大的标准库。Python语言的核心包含数字、字符串、列表...
  • Python课程,包含Python核心编程、数据库、web开发、爬虫、运维、人工智能等方向内容,带你畅游Python世界,帮助学习成为Python工程师。知道你是以下哪种情况,来看看:1.如果你认准学习Python技术,就是为了...
  • 写在前面:本文适合有高级编程语言基础的读者阅读。一、Python设计目标简单直观开源(Python源码...三、Python特点面向对象,在Python中一切皆对象有强大的标准库,Python语言的核心包含数字、字符串、列表、字...
  • 高级语言不能直接被机器所理解执行,所以都需要一个翻译阶段,解释型语言用到是解释器,编译型语言用到是编译器。 编译型语言通常执行过程是:源代码——预处理器——编译器——目标代码——链接器——可...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 210
精华内容 84
关键字:

python语言的核心不包含

python 订阅