python语言_python语言存在 - CSDN
精华内容
参与话题
  • python 的基本语句

    万次阅读 多人点赞 2018-08-28 16:03:29
    1.if 语句 1)基本用法: if 要判断的条件:  条件成立的时候,要做的事情 else:  条件不成立的时候,要做的事情   if和else语句以及各自的缩进部分都是一个完整的代码块 示例: ...elif 和 el...

    1.if 语句

    1)基本用法:

    if 要判断的条件:
        条件成立的时候,要做的事情

    else:
        条件不成立的时候,要做的事情
     
    if和else语句以及各自的缩进部分都是一个完整的代码块

    示例:

    2)if ,elif

    if 要判断的条件:
        条件成立的时候,要做的事情

    elif 条件2:

    else:
        条件不成立的时候,要做的事情

    elif 和 else 都必须和if 联合使用,不能单独使用

    3)if 嵌套

    基本结构

    if 条件1:
       条件1满足执行的代码
       if 满足条件1的基础上的条件2
      else:

       满足条件1的基础上不满足条件2

    else:
        条件1不满足时,执行的代码

    4)if 逻辑运算

    and:
    # 条件1 and 条件2
    # 两个条件同时满足,就返回True
    # 两个条件都不满足,返回False

    or:
    # 条件1 or 条件2
    # 两个条件只要有一个满足,就返回True
    # 两个条件都不满足,返回False

    5)if 综合案例

    题目:跟电脑猜拳

    注:

     在python中,要使用随机数,首先需要导入随即数模块 -- ‘工具包’
    导入模块后,可以直接在模块名称后面敲一个.然后Tab键,会提示该模块中包含的所有函数
    random.randint(a,b),返回[a b]之间的整数,包含a和b
    eg: random.randint(12,20):生成随机数n: 12 <= n <= 20
        random.randint(20,20): 结果永远是20
        random.randint(20,12):结果会报错:下限必须小于上限

     导入随即工具包
    # 注意,在导入工具包的时候,应该将导入的语句,放在文件的顶部
    # 因为,这样可以方便下方的代码,在任何需要的时候,使用工具包中的工具

    题目:

    1.输入年、月,输出本月有多少天。合理选择分支语句完成设计任务。
        输入样例1:2004 2
        输出结果1:本月29天
        输入样例2:2010 4
        输出结果2:本月30天

     2. 用 if 判断输入的值是否为空?如果为空,报错Error

     3. 根据用于指定月份,打印该月份所属的季节。
    **提示: 3,4,5 春季 6,7,8 夏季  9,10,11 秋季 12, 1, 2 冬季

    2.while 语句

    while 条件():
      条件满足时,做的事情1
      条件满足时,做的事情2

    例如:

    计算:0~100之间所有数字的累积求和
    注:python中的计数方法
    常见的计数方法有两种,可以分为
    自然计数法(从1开始) -- 更符合人类的习惯
    程序计数法(从0开始) -- 几乎所有的程序语言都选择从0开始计数
    因此,大家在编写程序时,应该尽量养成习惯:除非需求的特殊要求,否则循环的计数从0开始
    """
    """
    循环计算
    在程序开发中,通常会遇到利用循环重复计算的需求(利用CPU的强大之处 完成相应的复杂计算)
    遇到这种情况:
    1.在while上方定义一个变量,用于存放最终的计算结果
    2.在循环体内部,每次循环都用最新的计算结果,更新之前定义的变量
    """

    偶数求和

    奇数求和

    2)while 嵌套

    在控制台连续输出五行*,每一行星号的数量依次递增

    打印九九乘法表

    3.for 语句

    rang 的用法:

    for 循环使用的语法
        for 变量 in range(10):
            循环需要执行的代码

    for 循环综合应用

    用户登陆程序需求:
        1. 输入用户名和密码;
        2. 判断用户名和密码是否正确? (name='root', passwd='westos')
        3. 为了防止暴力破解, 登陆仅有三次机会, 如果超过三次机会, 报错提示;

    输入两个数值:
        求两个数的最大公约数和最小公倍数.
        最小公倍数=(num1*num2)/最大公约数

    4.三种退出命令的用法

    1)break

    break: 某一条件满足的时候,退出循环,不再执行后续重复的代码
    在循环体内部,我们可以增加额外的条件,在需要的时候,跳出整个循环

    2)continue

    某一条件满足的时候,不执行后续重复的代码,其他条件都要执行

    3)exit 直接退出

     

    展开全文
  • python语言介绍

    千次阅读 2017-12-16 10:19:26
    python是一种面向对象的解释型计算机程序设计语言,由荷兰人Guido van Rossum于1989年发明,第一个公开发行版发行于1991年。Python具有丰富和强大的库。它常被昵称为胶水语言,能够把用其他语言制作的各种模块(尤其...

      python是一种面向对象的解释型计算机程序设计语言,由荷兰人Guido van Rossum于1989年发明,第一个公开发行版发行于1991年。Python具有丰富和强大的库。它常被昵称为胶水语言,能够把用其他语言制作的各种模块(尤其是C/C++)很轻松地联结在一起。
    python


      python是一种用起来很方便的语言,很多初学Java的人都会被Java的CLASSPATH搞得晕头转向。用python就不会有这种问题,只要装上就能直接用。
      python是一种脚本语言,写好了就可以直接运行,省去了编译链接的麻烦,对于需要多动手实践的初学者而言,也就是少了出错的机会。而且python还有一种交互的方式,如果是一段简单的小程序,连编辑器都可以省了,直接敲进去就能运行。
      python是一种清晰的语言,用缩进来表示程序的嵌套关系可谓是一种创举,把过去软性的编程风格升级为硬性的语法规定。再不需要在不同的风格间选择、再不需要为不同的风格争执。python中没有各种隐晦的缩写,不需要去强记各种奇怪的符号的含义。python写的程序很容易懂,这是不少人的共识。
      python是一种面向对象的语言,但它的面向对象却不象C++那样强调概念,而是更注重实用。它用最简单的方法让编程者能够享受到面向对象带来的好处,这正是Python能像Java、C#那样吸引众多支持者的原因之一。
      python是一种功能丰富的语言,它拥有一个强大的基本类库和数量众多的第三方扩展。python为程序员提供了丰富的基本功能使得人们写程序时用不着一切最底层做起。
      人们通常会用一种担心:脚本语言通常很慢。但python的速度却比人们想象得快很多。虽然python是一种脚本语言,但实际上也可以对它进行编译,省去了对程序文本的分析解释,速度自然提升很多。


      python功能强大,但它却不是万能的,不同的语言适合做不同的事情,选择适合自己的语言工具是最重要的。

    展开全文
  • Python 语言简介与入门(1)

    千次阅读 2019-08-04 08:09:15
    Python 的创始人为吉多·范罗苏姆(Guido van Rossum).1989年的圣诞节期间,吉多·范罗苏姆为了在阿姆斯特丹打发时间,决心开发一个新的脚本解释程序,作为ABC语言的一种继承.Python是纯粹的自由软件,源代码和解释器...

    Python 的创始人为吉多·范罗苏姆(Guido van Rossum).1989年的圣诞节期间,吉多·范罗苏姆为了在阿姆斯特丹打发时间,决心开发一个新的脚本解释程序,作为ABC语言的一种继承.Python是纯粹的自由软件,源代码和解释器CPython遵循 GPL(GNU General Public License)协议.关于python的哲学:python崇尚:"优雅"、"明确"、"简单",Python是用最简单最优雅最明确的方法来解决问题.



    Python 语言简介

    Python 是一种动态解释型的编程语言,Python 简单易学、功能强大,支持面向对象、与函数式编程.Python可以在 Windows、Unix等多个操作系统上使用,同时Python也被称为"胶水语言",Python作为最流行的脚本语言之一,其具有内置的高级数据结构和简单有效的面向对象编程思想实现.同时语法简洁而清晰,类库丰富而强大,非常适合于进行快速原型开发,可以用最少的时间换取最高效的开发效率,另外Python可以运行在多种系统平台下,从而使得只需要编写一次代码,就可以在多个系统平台下都保持有同等的功能,这一点丝毫不逊色于Java虚拟机.

    Python 语言是由Guido van Rossum(吉多·范罗苏姆),在1989年开发的,1989年的圣诞节期间,吉多·范罗苏姆为了在阿姆斯特丹打发时间,决心开发一个新的脚本解释程序,以作为ABC语言的一种继承,其设计思想是简洁明了Python的设计具有很强的可读性,相比其他语言经常使用英文关键字,其他语言的一些标点符号,它具有比其他语言更有特色语法结构.

    Python 语言已经诞生20多年了,正逐渐发展为主流程序设计语言之一,目前在TIOBE编程语言排行榜中长期占据第4的位次,由于Python 语言的动态性,程序解释执行的速度比编译型语言慢,但随着Python语言的不断优化,一些诸如PyPy项目的不断发展,以及计算机硬件技术的不断发展,动态语言已经越来越受到工业领域的重视,另外最大的一点好处是,Python是纯粹的自由软件,源代码和解释器CPython遵循GPL(GNU General Public License)协议,Python的哲学就是崇尚"优雅"、"明确"、"简单",Python是用最简单最优雅最明确的方法来解决问题.

    Python 语言特点

    程序设计语言在不断发展,从最初的汇编语言到后来的C、Pascal语言,发展到现在的C++、Java等高级编程语言,程序设计的难度在不断减小,软件的开发和设计已经形成了一套标准,开发工作已经不再是复杂的任务.最初只能使用机器码编写代码,而现在可以使用具有良好调试功能的IDE环境编程,Python使用C语言开发,但是Python不再有C语言中的指针等复杂数据类型,Python的简洁性使得软件的代码大幅度地减少,开发任务进一步简化.

    面向对象的特性:
    面向对象的程序设计解决了结构化程序设计的复杂性,使得程序设计更贴近现实生活.结构化程序设计把数据和逻辑混合在一起,不便于程序的维护.面向对象的程序设计抽象出对象的行为和属性,把行为和属性分离开,但又合理地组织在一起.Python语言具有很强的面向对象特性,而且简化了面向对象的实现,它消除了保护类型、抽象类、接口等面向对象的元素,使得面向对象的概念更容易理解.

    内置的数据结构:
    Python提供了一些内置的数据结构,这些数据结构实现了类似Java中集合类的功能,Python的数据结构包括元组、列表、字典、集合等.内置数据结构的出现简化了程序的设计,元组相当于"只读"的数组,列表可以作为可变长度的数组使用,字典相当于Java中的HashTable类型.

    语言本身的简洁性:
    Python语言的关键字比较少,它没有分号、begin、end等标记符号,代码块使用空格或制表键进缩进方式来分割,其代码简洁、短小,易于阅读,Python简化了相关循环语句,就算非常复杂的语句,也能够快速读懂.

    语言本身的健壮性:
    Python提供了异常处理机制,能捕获程序的异常情况.此外Python的堆栈跟踪对象能够指出程序出错的位置和出错的原因,异常机制能够避免不安全退出的情况,同时能帮助程序员调试程序.

    跨平台(类似Java):
    Python代码会先编译为与平台相关的二进制代码,然后再解释执行,这种方式类似java,Python的执行速度提高了,Python编写的应用程序可以运行在 Windows、UNIX、Linux等,不同的操作系统上.

    Python 的应用领域

    ● 云计算:云计算最火的语言就是Pythhon,典型应用OpenStack框架就是使用Python开发的.
    ● WEB开发:众多优秀的WEB框架,众多大型网站均为Python开发,例如django框架.
    ● 人工智能:NumPy,SciPy,Matplotlib,Enthought,librarys这些框架是人工智能的主要实现.
    ● 系统运维:运维人员开发脚本进行自动化管理,由于所有的Linux/Mac默认集成Python环境.
    ● 金融计算:量化交易,金融分析,金融工程领域的广泛应用.
    ● 黑客编程:拥有大量的黑客攻击模块,可以很方便的使用这些模块.
    ● 图形GUI:PyQT,WxPython,TkInter等图形框架,现在已经逐步变得更加的完善.

    Python 这些公司在用

    ● 谷歌:Google App Engine 谷歌爬虫等项目都在大量使用Python
    ● CIA:美国中情局网站就是用Python开发的
    ● NASA:美国航天局(NASA)大量使用Python进行数据分析和运算
    ● YouTube:世界上最大的视频网站YouTube就是用Python开发的
    ● Dropbox:美国最大的在线云存储网站,全部用Python实现,每天网站处理10亿个文件的上传和下载
    ● Facebook:大量的基础库均通过Python实现的
    ● Redhat:世界上最流行的Linux发行版本中的yum包管理工具就是用python开发的
    ● 豆瓣:豆瓣公司几乎所有的业务均是通过Python开发

    Python 语言的优缺点

    ● 优雅:Python程序看上去总是简单易懂,可以编写那些非常非常复杂的程序.
    ● 效率:Python有非常强大的第三方库,避免重复造轮子,开发效率非常高.
    ● 高级语言:用Python语言编写程序的时候,你无需考虑诸如如何管理程序使用的内存的底层细节.
    ● 可移植性:由于开源本质,已经被移植在许多平台上,您写的程序可以不加修改的运行在任何系统上.
    ● 可扩展性:Python被称作胶水语言可以与各种语言实现的功能交互互相调用.
    ● 可嵌入性:你可以把Python嵌入你的C/C++程序,从而向你的程序用户提供脚本功能.
    ● 速度慢:Python是脚本语言,解释执行所以其执行效率很低,但一般工作足以应对.
    ● 代码不能加密:python是解释语言代码,无法加密,开源精神很重要.
    ● 线程不能利用多CPU问题:GIL即全局解释器锁,使得任何时刻仅有一个线程在执行.

    以上就是全部的关于Python的简单介绍了,具体如果想进一步了解Python的其他历史,请自行问度娘.

    Python 编译安装

    Python的开发环境安装和配置非常的简单,如果是Linux系统则会默认集成安装了Python环境,Python的可执行文件被放在了/usr/local/bin目录下,库函数被安装在了/usr/local/python目录中,接下来我们将使用源码的方式来编译安装一下Python解释器.

    1.首先安装gcc编译器,和Python的相关依赖包.

    [root@localhost ~]# yum -y install gcc zlib zlib-devel openssl openssl-devel libffi-devel
    
    Package gcc-4.8.5-36.el7.x86_64 already installed and latest version
    Package zlib-1.2.7-18.el7.x86_64 already installed and latest version
    Package zlib-devel-1.2.7-18.el7.x86_64 already installed and latest version
    Package 1:openssl-1.0.2k-16.el7.x86_64 already installed and latest version
    Package 1:openssl-devel-1.0.2k-16.el7.x86_64 already installed and latest version
    Package libffi-devel-3.0.13-18.el7.x86_64 already installed and latest version
    Nothing to do

    2.这里我们需要编译并安装Python解释器.

    [root@localhost ~]# yum install -y readline
    [root@localhost ~]# wget https://www.python.org/ftp/python/3.7.0/Python-3.7.0.tgz
    [root@localhost ~]# tar xvzf Python-3.7.0.tgz -C /usr/src/python3.7
    [root@localhost ~]# cd /usr/src/Python-3.7.0/
    [root@localhost ~]# ./configure --prefix=/usr/local/python3.7
    [root@localhost ~]# make && make altinstall

    3.将Python头文件拷贝到标准目录,避免直接使用Python找不到所需的头文件.

    [root@localhost ~]# cd /usr/local/include/python3.7/
    [root@localhost ~]# cp -a ./* /usr/local/include/

    4.接着我们备份一下旧版本的Python,并创建符号链接链接到新版本的Python上面.

    [root@localhost ~]# cd /usr/bin/
    [root@localhost bin]# mv python python.old
    [root@localhost bin]# ln -s /usr/local/bin/python3.7 /usr/local/bin/python
    [root@localhost bin]# rm -rf /usr/bin/python
    [root@localhost bin]# cp /usr/local/bin/python3.7 /usr/bin/python

    5.由于yum是用Python开发的,这里为了避免冲突要改掉他的配置.

    [root@localhost ~]# vim /usr/bin/yum
    #!/usr/bin/python2.7       ←此处将python改成python2.7
    
    [root@localhost ~]# vim /usr/libexec/urlgrabber-ext-down
    #!/usr/bin/python2.7       ←此处将python改成python2.7

    6.最后测试python新版本是否生效了.

    [root@localhost ~]# python
    Python 3.7.0 (default, Apr 17 2018, 11:03:21) 
    [GCC 4.8.5 20150623 (Red Hat 4.8.5-11)] on linux
    Type "help", "copyright", "credits" or "license" for more information.
    >>> exit()


    Python 输入输出

    ◆Input标准输入◆

    python3中格式化输出默认接收的都视为字符串,如果需要数字则需要另外强制转换为int()转换为数字.

    >>> name = input("请输入你的名字:")
    请输入你的名字:lyshark
    >>> print("Hello " + name)
    Hello lyshark
     
    >>> age = input("请输入你的年龄:")
    请输入你的年龄:22
    >>> type(age)
    <class 'str'>         #默认情况是字符串
     
    >>> age1 = input("请输入你的年龄:")
    >>> age1 = int(age1)  #此处强制类型转换
    >>> type(age1)
    <class 'int'>         #再次查询已变成整形

    输入密码时,如果想要不可见,需要利用getpass模块中的getpass方法,即:

    import getpass
      
    # 将用户输入的内容赋值给 pwd 变量
    pwd = getpass.getpass("请输入密码:")
    请输入密码:
    
    # 打印输入的内容
    print(pwd)

    ◆Print标准输出◆

    输出字符串: 格式化输出字符串.

    >>> str="hello python"
    >>> print(str)
    hello python

    输出整数: 格式化输出整数.

    >>> strHello="the length of (%s) is %d" %("hello world",len("hello world"))
    >>> print(strHello)
    the length of (hello world) is 11

    进制输出: 格式化输出十进制,十六进制,八进制.

    >>> nHex=0x20
    >>> print("十六进制=%x,十进制=%d,八进制=%o"%(nHex,nHex,nHex))
    十六进制=20,十进制=32,八进制=40

    二进制输出: 格式化输出二进制,可以使用python函数bin().

    >>> bin(155)
    '0b10011011'

    格式化输出浮点数(float):

    >>> import math
    >>> print("PI=%F"%math.pi)
    PI=3.141593
    >>> print("PI=%10.2f"%math.pi)
    PI=      3.14
    >>> print("PI=%-10.2f"%math.pi)
    PI=3.14

    格式化输出字符串(string):

    >>> print("%3s"%("lyshark"))
    lyshark
    >>> print("%3s"%("lyshark"))
    lyshark
    >>> print("%.*s"%(4,"lyshark"))
    lysh
    >>> print("%10.3s"%("lyshark"))
           lys

    输出一个列表(list):

    >>> list=[1,2,3,4,5,"lyshark"]
    >>> print(list)
    [1, 2, 3, 4, 5, 'lyshark']
    >>>
    >>> dic={1:"A",2:"b",3:"c"}
    >>> print(dic)
    {1: 'A', 2: 'b', 3: 'c'}

    自动换行: print会自动在行末加上回车,如果不需回车,只需要加上,即可.

    >>> for i in range(0,5):
    ...     print(i,)

    万能的%参数:

    >>> format="%r %r %r %r"
    >>> print(format%(1,2,3,4))
    1 2 3 4

    格式化打印: 让多个print打印在一行内.

    print('hello', end = " ")  
    print('world', end = "*")  
    print('!')  
    """ 
    输出结果是: 
    hello world*! 
    """

    字符串拼接:

    >>> str1="hello"
    >>> str2="lyshark"
    >>> print(str1+str2)
    hellolyshark

    拓展知识: 打印一个乘法口诀表.

    for i in range(1,10):
        for m in range (1,i+1):
            sum = i * m
            if m < i:
                print(m, '*', i,  '=', sum ,end= '   ') 
            else:
                print(m, '*', i, '=', sum)


    Python 模块概述

    sys模块:

    import sys
      
    print(sys.argv)
    
    root@localhost:~$ python test.py helo world
    
    ['test.py', 'helo', 'world']      #把执行脚本时传递的参数获取到了 

    os模块:

    >>> import os
    >>> os.system("df -h") #调用系统命令

    os.system()执行系统命令,如果有变量存储该执行的结果,该变量只会存储该命令执行成功或者失败返回值,不会存储命令执行的结果,os.system("df -h")会有返回值.

    >>> result = os.system("df -h")
    df: ‘/mnt/hgfs’: Protocol error
    Filesystem      Size  Used Avail Use% Mounted on
    udev            3.9G     0  3.9G   0% /dev
    tmpfs           797M  9.4M  788M   2% /run
    /dev/sda1       189G   10G  170G   6% /

    如果需要保存命令执行的结果需哟使用os.popen("系统命令").read(),然后使用变量赋值输出.

    >>> result = os.popen("df -h").read()
     
    >>> print(result)
    Filesystem      Size  Used Avail Use% Mounted on
    udev            3.9G     0  3.9G   0% /dev
    tmpfs           797M  9.4M  788M   2% /run
    /dev/sda1       189G   10G  170G   6% /

    自己写个补全模块tab.py:

    #!/usr/bin/env python 
    # python startup file 
    import sys
    import readline
    import rlcompleter
    import atexit
    import os
    # tab completion 
    readline.parse_and_bind('tab: complete')
    # history file 
    histfile = os.path.join(os.environ['HOME'], '.pythonhistory')
    try:
        readline.read_history_file(histfile)
    except IOError:
        pass
    atexit.register(readline.write_history_file, histfile)
    del os, histfile, readline, rlcompleter

    写完后保存,导入就可以使用,按下tab看到补全效果了.

    >>> import tab
    >>> import os
    >>> os.
    Display all 238 possibilities? (y or n)
    os.EX_CANTCREAT             os.fchdir(
    os.EX_CONFIG                os.fchmod(
    os.EX_DATAERR               os.fchown(


    Python 文件生成

    Python 并非完全是解释性语言,它是有编译的,先把源码py文件编译成pyc或者pyo,然后由Python的虚拟机执行,相对于py文件来说,编译成pyc和pyo本质上和py没有太大区别,只是对于这个模块的加载速度提高了,并没有提高代码的执行速度,通常情况下不用主动去编译pyc文件,文档上说只要调用了import model那么model.py就会先编译成pyc然后加载.

    当python程序运行时,编译的结果则是保存在位于内存中的PyCodeObject中,当Python程序运行结束时,Python解释器则将PyCodeObject写回到pyc文件中.

    当python程序第二次运行时,首先程序会在硬盘中寻找pyc文件,如果找到,先对.pyc文件和.py文件的最近一次的修改时间进行判断,如果.pyc文件的修改时间晚于.py文件,说明.py文件中的源代码未修改过,则直接载入,否则就重复上面的过程.

    所以我们应该这样来定位PyCodeObject和pyc文件,我们说pyc文件其实是PyCodeObject的一种持久化保存方式.

    ◆生成PY文件◆

    编译成pyc文件: 将我们写好的一个.py文件编译成.pyc文件.

    [root@localhost ~]# ls -lh
    total 4.0K
    -rw-r--r--. 1 root root 43 Jan  8 02:22 test.py
    
    [root@localhost ~]# python -m test.py
    [root@localhost ~]# ls -lh
    total 8.0K
    -rw-r--r--. 1 root root  43 Jan  8 02:22 test.py
    -rw-r--r--. 1 root root 163 Jan  8 02:25 test.pyo

    编译成pyo文件: 将我们写好的一个.py文件编译成.pyo文件.

    [root@localhost ~]# ls -lh
    total 4.0K
    -rw-r--r--. 1 root root 43 Jan  8 02:22 test.py
    
    [root@localhost ~]# python  -O -m test.py
    [root@localhost ~]# ls -lh
    total 8.0K
    -rw-r--r--. 1 root root  43 Jan  8 02:22 test.py
    -rw-r--r--. 1 root root 163 Jan  8 02:25 test.pyo

    ◆打包EXE文件◆

    1.通过pip安装打包工具pyinstaller.

    [root@localhost ~]# yum install -y python-pip
    
    Package python2-pip-8.1.2-6.el7.noarch already installed and latest version
    Nothing to do
    
    [root@localhost ~]# pip install pyinstaller
    Collecting pyinstaller
      Downloading https://files.pythonhosted.org/pyinstall

    2.准备测试文件,执行以下命令加密生成可执行文件.

    [root@localhost ~]# ls -lh
    total 4.0K
    -rw-r--r--. 1 root root 43 Jan  8 02:22 test.py
    
    [root@localhost ~]# pyinstaller -F ./test.py
    44 INFO: PyInstaller: 3.4
    44 INFO: Python: 2.7.5
    44 INFO: Platform: Linux-3.10.0-862.el7.x86_64-x86_64-with-centos-7.5.1804-Core
    44 INFO: wrote /root/test.spec
    152 INFO: UPX is not available.
    155 INFO: Extending PYTHONPATH with paths
    ......

    3.然后查看,在当前目录会看到生成个3个目录,其中dist目录中的内容,就是生成的可执行文件.

    [root@localhost ~]# ls -lh
    total 8.0K
    drwxr-xr-x. 3 root root  18 Jan  8 02:29 build
    drwxr-xr-x. 2 root root  18 Jan  8 02:29 dist
    -rw-r--r--. 1 root root  43 Jan  8 02:22 test.py
    -rw-r--r--. 1 root root 786 Jan  8 02:29 test.spec
    
    [root@localhost dist]# ls -lh
    total 4.7M
    -rwxr-xr-x. 1 root root 4.6M Jan  8 02:29 test
    
    [root@localhost dist]# ./test
    hello world


    转载于:https://www.cnblogs.com/LyShark/p/11295854.html

    展开全文
  • Python语言十分钟快速入门

    千次阅读 2016-09-26 19:51:53
    假设你希望学习Python这门语言,却苦于找不到一个简短而全面的入门教程。那么本教程将花费十分钟的时间带你走入Python的大门。...在此,我会假定你已经有了一定的编程基础,因此我会跳过大部分非Python语言的相

    假设你希望学习Python这门语言,却苦于找不到一个简短而全面的入门教程。那么本教程将花费十分钟的时间带你走入Python的大门。本文的内容介于教程(Toturial)和速查手册(CheatSheet)之间,因此只会包含一些基本概念。很显然,如果你希望真正学好一门语言,你还是需要亲自动手实践的。在此,我会假定你已经有了一定的编程基础,因此我会跳过大部分非Python语言的相关内容。本文将高亮显示重要的关键字,以便你可以很容易看到它们。另外需要注意的是,由于本教程篇幅有限,有很多内容我会直接使用代码来说明加以少许注释。

    Python的语言特性

    Python是一门具有强类型(即变量类型是强制要求的)、动态性、隐式类型(不需要做变量声明)、大小写敏感(var和VAR代表了不同的变量)以及面向对象(一切皆为对象)等特点的编程语言。

    获取帮助

    你可以很容易的通过Python解释器获取帮助。如果你想知道一个对象(object)是如何工作的,那么你所需要做的就是调用help(<object>)!另外还有一些有用的方法,dir()会显示该对象的所有方法,还有<object>.__doc__会显示其文档:

    >>> help(5)
    Help on int object:
    (etc etc)
    
    >>> dir(5)
    ['__abs__', '__add__', ...]
    
    >>> abs.__doc__
    'abs(number) -> number
    
    Return the absolute value of the argument.'

     

    语法

    Python中没有强制的语句终止字符,且代码块是通过缩进来指示的。缩进表示一个代码块的开始,逆缩进则表示一个代码块的结束。声明以冒号(:)字符结束,并且开启一个缩进级别。单行注释以井号字符(#)开头,多行注释则以多行字符串的形式出现。赋值(事实上是将对象绑定到名字)通过等号(“=”)实现,双等号(“==”)用于相等判断,”+=”和”-=”用于增加/减少运算(由符号右边的值确定增加/减少的值)。这适用于许多数据类型,包括字符串。你也可以在一行上使用多个变量。例如:

    >>> myvar = 3
    >>> myvar += 2
    >>> myvar
    5
    >>> myvar -= 1
    >>> myvar
    4
    """This is a multiline comment.
    The following lines concatenate the two strings."""
    >>> mystring = "Hello"
    >>> mystring += " world."
    >>> print mystring
    Hello world.
    # This swaps the variables in one line(!).
    # It doesn't violate strong typing because values aren't
    # actually being assigned, but new objects are bound to
    # the old names.
    >>> myvar, mystring = mystring, myvar

    数据类型

    Python具有列表(list)、元组(tuple)和字典(dictionaries)三种基本的数据结构,而集合(sets)则包含在集合库中(但从Python2.5版本开始正式成为Python内建类型)。列表的特点跟一维数组类似(当然你也可以创建类似多维数组的“列表的列表”),字典则是具有关联关系的数组(通常也叫做哈希表),而元组则是不可变的一维数组(Python中“数组”可以包含任何类型的元素,这样你就可以使用混合元素,例如整数、字符串或是嵌套包含列表、字典或元组)。数组中第一个元素索引值(下标)为0,使用负数索引值能够从后向前访问数组元素,-1表示最后一个元素。数组元素还能指向函数。来看下面的用法:

    >>> sample = [1, ["another", "list"], ("a", "tuple")]
    >>> mylist = ["List item 1", 2, 3.14]
    >>> mylist[0] = "List item 1 again" # We're changing the item.
    >>> mylist[-1] = 3.21 # Here, we refer to the last item.
    >>> mydict = {"Key 1": "Value 1", 2: 3, "pi": 3.14}
    >>> mydict["pi"] = 3.15 # This is how you change dictionary values.
    >>> mytuple = (1, 2, 3)
    >>> myfunction = len
    >>> print myfunction(mylist)
    3

    你可以使用:运算符访问数组中的某一段,如果:左边为空则表示从第一个元素开始,同理:右边为空则表示到最后一个元素结束。负数索引则表示从后向前数的位置(-1是最后一个项目),例如:

    >>> mylist = ["List item 1", 2, 3.14]
    >>> print mylist[:]
    ['List item 1', 2, 3.1400000000000001]
    >>> print mylist[0:2]
    ['List item 1', 2]
    >>> print mylist[-3:-1]
    ['List item 1', 2]
    >>> print mylist[1:]
    [2, 3.14]
    # Adding a third parameter, "step" will have Python step in
    # N item increments, rather than 1.
    # E.g., this will return the first item, then go to the third and
    # return that (so, items 0 and 2 in 0-indexing).
    >>> print mylist[::2]
    ['List item 1', 3.14]

    字符串

    Python中的字符串使用单引号(‘)或是双引号(“)来进行标示,并且你还能够在通过某一种标示的字符串中使用另外一种标示符(例如 “He said ‘hello’.”)。而多行字符串可以通过三个连续的单引号(”’)或是双引号(“””)来进行标示。Python可以通过u”This is a unicode string”这样的语法使用Unicode字符串。如果想通过变量来填充字符串,那么可以使用取模运算符(%)和一个元组。使用方式是在目标字符串中从左至右使用%s来指代变量的位置,或者使用字典来代替,示例如下:

    >>>print "Name: %s
    Number: %s
    String: %s" % (myclass.name, 3, 3 * "-")
    Name: Poromenos
    Number: 3
    String: ---
    
    strString = """This is
    a multiline
    string."""
    
    # WARNING: Watch out for the trailing s in "%(key)s".
    >>> print "This %(verb)s a %(noun)s." % {"noun": "test", "verb": "is"}
    This is a test.

    流程控制

    Python中可以使用if、for和while来实现流程控制。Python中并没有select,取而代之使用if来实现。使用for来枚举列表中的元素。如果希望生成一个由数字组成的列表,则可以使用range(<number>)函数。以下是这些声明的语法示例:

    rangelist = range(10)
    >>> print rangelist
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    for number in rangelist:
        # Check if number is one of
        # the numbers in the tuple.
        if number in (3, 4, 7, 9):
            # "Break" terminates a for without
            # executing the "else" clause.
            break
        else:
            # "Continue" starts the next iteration
            # of the loop. It's rather useless here,
            # as it's the last statement of the loop.
            continue
    else:
        # The "else" clause is optional and is
        # executed only if the loop didn't "break".
        pass # Do nothing
    
    if rangelist[1] == 2:
        print "The second item (lists are 0-based) is 2"
    elif rangelist[1] == 3:
        print "The second item (lists are 0-based) is 3"
    else:
        print "Dunno"
    
    while rangelist[1] == 1:
        pass

    函数

    函数通过“def”关键字进行声明。可选参数以集合的方式出现在函数声明中并紧跟着必选参数,可选参数可以在函数声明中被赋予一个默认值。已命名的参数需要赋值。函数可以返回一个元组(使用元组拆包可以有效返回多个值)。Lambda函数是由一个单独的语句组成的特殊函数,参数通过引用进行传递,但对于不可变类型(例如元组,整数,字符串等)则不能够被改变。这是因为只传递了该变量的内存地址,并且只有丢弃了旧的对象后,变量才能绑定一个对象,所以不可变类型是被替换而不是改变(译者注:虽然Python传递的参数形式本质上是引用传递,但是会产生值传递的效果)。例如:

    # 作用等同于 def funcvar(x): return x + 1
    funcvar = lambda x: x + 1
    >>> print funcvar(1)
    2
    
    # an_int 和 a_string 是可选参数,它们有默认值
    # 如果调用 passing_example 时只指定一个参数,那么 an_int 缺省为 2 ,a_string 缺省为 A default string。如果调用 passing_example 时指定了前面两个参数,a_string 仍缺省为 A default string。
    # a_list 是必备参数,因为它没有指定缺省值。
    def passing_example(a_list, an_int=2, a_string="A default string"):
        a_list.append("A new item")
        an_int = 4
        return a_list, an_int, a_string
    
    >>> my_list = [1, 2, 3]
    >>> my_int = 10
    >>> print passing_example(my_list, my_int)
    ([1, 2, 3, 'A new item'], 4, "A default string")
    >>> my_list
    [1, 2, 3, 'A new item']
    >>> my_int
    10

    Python支持有限的多继承形式。私有变量和方法可以通过添加至少两个前导下划线和最多尾随一个下划线的形式进行声明(如“__spam”,这只是惯例,而不是Python的强制要求)。当然,我们也可以给类的实例取任意名称。例如:

    class MyClass(object):
        common = 10
        def __init__(self):
            self.myvariable = 3
        def myfunction(self, arg1, arg2):
            return self.myvariable
    
        # This is the class instantiation
    >>> classinstance = MyClass()
    >>> classinstance.myfunction(1, 2)
    3
    # This variable is shared by all classes.
    >>> classinstance2 = MyClass()
    >>> classinstance.common
    10
    >>> classinstance2.common
    10
    # Note how we use the class name
    # instead of the instance.
    >>> MyClass.common = 30
    >>> classinstance.common
    30
    >>> classinstance2.common
    30
    # This will not update the variable on the class,
    # instead it will bind a new object to the old
    # variable name.
    >>> classinstance.common = 10
    >>> classinstance.common
    10
    >>> classinstance2.common
    30
    >>> MyClass.common = 50
    # This has not changed, because "common" is
    # now an instance variable.
    >>> classinstance.common
    10
    >>> classinstance2.common
    50
    
    # This class inherits from MyClass. The example
    # class above inherits from "object", which makes
    # it what's called a "new-style class".
    # Multiple inheritance is declared as:
    # class OtherClass(MyClass1, MyClass2, MyClassN)
    class OtherClass(MyClass):
        # The "self" argument is passed automatically
        # and refers to the class instance, so you can set
        # instance variables as above, but from inside the class.
        def __init__(self, arg1):
            self.myvariable = 3
            print arg1
    
    >>> classinstance = OtherClass("hello")
    hello
    >>> classinstance.myfunction(1, 2)
    3
    # This class doesn't have a .test member, but
    # we can add one to the instance anyway. Note
    # that this will only be a member of classinstance.
    >>> classinstance.test = 10
    >>> classinstance.test
    10

    异常

    Python中的异常由 try-except [exceptionname] 块处理,例如:

    def some_function():
        try:
            # Division by zero raises an exception
            10 / 0
        except ZeroDivisionError:
            print "Oops, invalid."
        else:
            # Exception didn't occur, we're good.
            pass
        finally:
            # This is executed after the code block is run
            # and all exceptions have been handled, even
            # if a new exception is raised while handling.
            print "We're done with that."
    
    >>> some_function()
    Oops, invalid.
    We're done with that.

    导入

    外部库可以使用 import [libname] 关键字来导入。同时,你还可以用 from [libname] import [funcname] 来导入所需要的函数。例如:

    import random
    from time import clock
    
    randomint = random.randint(1, 100)
    >>> print randomint
    64

    文件I / O

    Python针对文件的处理有很多内建的函数库可以调用。例如,这里演示了如何序列化文件(使用pickle库将数据结构转换为字符串):

    import pickle
    mylist = ["This", "is", 4, 13327]
    # Open the file C:binary.dat for writing. The letter r before the
    # filename string is used to prevent backslash escaping.
    myfile = open(r"C:binary.dat", "w")
    pickle.dump(mylist, myfile)
    myfile.close()
    
    myfile = open(r"C:text.txt", "w")
    myfile.write("This is a sample string")
    myfile.close()
    
    myfile = open(r"C:text.txt")
    >>> print myfile.read()
    'This is a sample string'
    myfile.close()
    
    # Open the file for reading.
    myfile = open(r"C:binary.dat")
    loadedlist = pickle.load(myfile)
    myfile.close()
    >>> print loadedlist
    ['This', 'is', 4, 13327]

    其它杂项

    • 数值判断可以链接使用,例如 1<a<3 能够判断变量 a 是否在1和3之间。
    • 可以使用 del 删除变量或删除数组中的元素。
    • 列表推导式(List Comprehension)提供了一个创建和操作列表的有力工具。列表推导式由一个表达式以及紧跟着这个表达式的for语句构成,for语句还可以跟0个或多个if或for语句,来看下面的例子:
    >>> lst1 = [1, 2, 3]
    >>> lst2 = [3, 4, 5]
    >>> print [x * y for x in lst1 for y in lst2]
    [3, 4, 5, 6, 8, 10, 9, 12, 15]
    >>> print [x for x in lst1 if 4 > x > 1]
    [2, 3]
    # Check if an item has a specific property.
    # "any" returns true if any item in the list is true.
    >>> any([i % 3 for i in [3, 3, 4, 4, 3]])
    True
    # This is because 4 % 3 = 1, and 1 is true, so any()
    # returns True.
    
    # Check how many items have this property.
    >>> sum(1 for i in [3, 3, 4, 4, 3] if i == 4)
    2
    >>> del lst1[0]
    >>> print lst1
    [2, 3]
    >>> del lst1
    • 全局变量在函数之外声明,并且可以不需要任何特殊的声明即能读取,但如果你想要修改全局变量的值,就必须在函数开始之处用global关键字进行声明,否则Python会将此变量按照新的局部变量处理(请注意,如果不注意很容易被坑)。例如:
      number = 5
      
      def myfunc():
          # This will print 5.
          print number
      
      def anotherfunc():
          # This raises an exception because the variable has not
          # been bound before printing. Python knows that it an
          # object will be bound to it later and creates a new, local
          # object instead of accessing the global one.
          print number
          number = 3
      
      def yetanotherfunc():
          global number
          # This will correctly change the global.
          number = 3

    小结

    本教程并未涵盖Python语言的全部内容(甚至连一小部分都称不上)。Python有非常多的库以及很多的功能特点需要学习,所以要想学好Python你必须在此教程之外通过其它方式,例如阅读Dive into Python。我希望这个教程能给你一个很好的入门指导。如果你觉得本文还有什么地方值得改进或添加,或是你希望能够了解Python的哪方面内容,请留言。

    相关文章:

    ;
    展开全文
  • C语言和Python语言有什么区别呢?

    万次阅读 2019-07-29 13:24:00
    最近几年python语言非常受大家欢迎,所以我也想学习了解下python语言,但是学习之前总是有很多疑问。 因为我现在只会汇编和C语言,所有我想在学习它之前先了解一下python和我常用的C语言有什么不一样的地方,有什么...
  • Python 语言历史简介

    千次阅读 2017-12-15 20:15:36
    Python是一种解释型的、面向对象的、带有动态语义的高级编程语言。它由荷兰人Guido van Rossum于1989年发明,第一个公开发行版发行于1991年。 Python的发明者曾参与ABC语言的开发,这种语言与当时主流的语言有较大...
  • 第一眼看到这个问题的时候,潜意识地看了一下问题日志,果不其然,问题发表于2011年,据今已有7年时间,随着这两年人工智能大热,作为AI届的“网红”,Python的地位也有一定变化,所以今天再把这个问题扒出来研究...
  • Python语言是编译型语言还是解释型语言? 我们都知道,编程语言从程序执行过程分,分为编译型语言和解释性语言 什么是编译型语言和解释型语言? Python是一种解释型语言 Python程序源码不需要编译,可以直接从源...
  • Python 语言发展历史

    千次阅读 2017-12-14 14:49:50
    Python 是一门简洁而又强大的编程语言。相信即使是刚接触编程的同学也一定听说过「人生苦短,我用 Python(Life is short. You need Python.)」这句话。目前人工智能越来越火,Python 凭借它扩展性强、第三方库丰富...
  • python语言的特点和优缺点

    万次阅读 2018-10-05 22:00:42
    python语言的特点和优缺点 python的特点: 1.是一种解释性的语言 2.是一种交互式的语言 3.是一种面向对象的语言 4.是一种跨平台的语言 python的优缺点: 优点: 1.易于阅读和维护 2.有一个广泛的标准库 3....
  • 本书下载链接: https://download.csdn.net/download/u010752028/10575288
  • Python初级入门精讲

    万人学习 2020-08-25 15:56:32
    本课程为Python全栈开发初级入门篇-语言基础章节,学习完本篇章可对python语言有初步的掌握与理解,本课程侧重于初级学员,课程内容详细有针对性,务求各种类型的学员都可以掌握python开发。
  • Python和R语言之间的详细对比

    万次阅读 2019-01-23 20:07:54
    在从事数据分析行业中,我们都会从R与Python当中进行选择,但是,从这两个异常强大、灵活好用的数据分析语中选择,却是非常难以选择的。 为了让大家能选择出更适合大家,我们将两种语言的信处做个对比,把决策权...
  • 使用 Python 和另一种语言混编的好处 至少有以下四个原因: Best of both worlds - 结合两种语言的优点:已经优化和测试过的代码库 + Python 的灵活 Python as glue - Python 作为连接的桥梁,将很多其他语言的...
  • 数百种编程语言,而我为什么要学 Python

    万次阅读 多人点赞 2017-11-17 11:45:56
    如果让你从数百种的编程语言中选择一个入门语言?你会选择哪一个?
  • Python2TheMax

    万人学习 2019-10-31 14:31:04
    免费入群领取【超全Python资料包+17本学习电子书】 5周179学时,干货满满,诚意满满; 基本语法、面向对象、GUI、游戏开发、程序测试...应有尽有! 既不乏Bigger工程,又有超多好玩的小例子...
  • 做数据分析、科学计算等离不开工具、语言的使用,目前最流行的数据语言,无非是MATLAB,R语言,Python这三种语言,但今天大圣众包(www.dashengzb.cn)小编简单总结了python语言的一些特点及平常使用的工具等。...
  • python是强类型语言还是弱类型语言

    千次阅读 2019-03-13 21:48:24
    Python属于强类型的动态脚本语言 强类型:不予许不同类型相加 动态:不使用显示数据声明类型,且确定一个变量的类型是第一次给他赋值的时候 脚本语言:一般也是解释性语言,运行代码只需要一个解释器,不需要编译...
  • Python开发介绍(第一季)

    万人学习 2019-09-26 18:19:32
    您观看课程学习后 免费入群领取【超全... 本季教程(Python开发教程分为两季)适合想从零开始学习Python编程语言的开发人员,该课程主要学习 Python 语法特点,认识Python语言的优缺点和在Mac下的开发坏境的搭建。
  • python到底是什么类型的语言

    万次阅读 2018-03-16 16:35:35
    写程序方便对做机器学习的人来说非常重要,因为经常需要对模型进行各种各样的修改,这在编译语言里很可能是牵一发而动全身的事情,而Python语言则可以用更少的时间来实现,因此Python语言几乎成为了人工智能的专属...
1 2 3 4 5 ... 20
收藏数 644,705
精华内容 257,882
关键字:

python语言