zoukankan      html  css  js  c++  java

  • Python 基础语法（和Java相比）

    Python变量和数据类型

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    #数据类型
    print(0xff00); #十六进制用0x前缀和0-9，a-f表示
     
    print(1.23e9); # 对于非常大或非常小的浮点数。就必须用科学计数法表示。把10用e替代。1.23x10^9就是1.23e9，或者12.3e8，0.000012能够写成1.2e-5，等等。
     
    #在Python中，能够直接用True、False表示布尔值（请注意大写和小写）布尔值能够用and、or和not运算。

     
    #空值是Python里一个特殊的值，用None表示。None不能理解为0。由于0是有意义的，而None是一个特殊的空值。
     
     
    #----------------------------------------
    #print语句
    print 'hello, world'
    print 'The quick brown fox', 'jumps over', 'the lazy dog' #遇到逗号“,”会输出一个空格
    print '100 + 200 =', 100 + 200 #计算100 + 200的结果
     
    #--------------------------------------------
    #变量
    a = 1 #变量是用一个变量名表示，变量名必须是大写和小写英文、数字和_的组合。且不能用数字开头
     
    #能够把随意数据类型赋值给变量。同一个变量能够反复赋值，并且能够是不同类型的变量，称为动态语言
     
    #-------------------------------------------
    #能够使用转义字符  、 、 等等
     
    #-------------------------------------------
    #raw字符串与多行字符串
    print (r'(~_~)/ (~_~)/'); #我们能够在字符串前面加个前缀 r 。表示这是一个 raw 字符串，里面的字符就不须要转义了
     
    #可是r'...'表示法不能表示多行字符串，也不能表示包括'和 "的字符串
    #假设要表示多行字符串，能够用'''...'''表示
    print ('''Python is created by "Guido".
    It is free and easy to learn.
    Let's start learn Python in imooc!''');  #等同于'Line 1 Line 2 Line 3'
     
    #---------------------------------------------------
    #Python在后来加入了对Unicode的支持。以Unicode表示的字符串用u'...'表示，比方：
    print u'中文'
     
    #假设中文字符串在Python环境下遇到 UnicodeDecodeError。这是由于.py文件保存的格式有问题。能够在第一行加入凝视(目的是告诉Python解释器。用UTF-8编码读取源码。)
    # -*- coding: utf-8 -*-  
     
    #---------------------------------------------------
    #布尔类型
    a = True 
    print a and 'a=T' or 'a=F'
    #计算结果不是布尔类型，而是字符串 'a=T'，这是为什么呢？
    #由于Python把0、空字符串''和None看成 False，其它数值和非空字符串都看成 True，所以：
    a and 'a=T' #计算结果是 'a=T'
    print a and 'a=T' or 'a=F' #计算结果还是 'a=T'
     
    #要解释上述结果，又涉及到 and 和 or 运算的一条重要法则：短路计算。
    #1. 在计算 a and b 时，假设 a 是 False，则依据与运算法则，整个结果必然为 False。因此返回 a；假设 a 是 True。则整个计算结果必然取决与 b，因此返回 b。

    #2. 在计算 a or b 时，假设 a 是 True，则依据或运算法则，整个计算结果必然为 True。因此返回 a；假设 a 是 False。则整个计算结果必然取决于 b，因此返回 b。
    #所以Python解释器在做布尔运算时，仅仅要能提前确定计算结果，它就不会往后算了，直接返回结果。

    List和Tuple类型

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    #list是一种有序的集合，能够随时加入和删除当中的元素
     
    #一个元素能够没有的list。就是空list：
    empty_list = [] 
     
    #创建List
    L = ['Adam', 95.5, 'Lisa', 85, 'Bart', 59]
    print L
     
    #依照索引訪问list
    print L[4] #输出Bart。下标是从0開始
     
    #倒序訪问list
    print L[-2] #输出Bart，下标是从0開始
     
    #加入新元素
    L.append('Paul') 
    L.insert(0, 'Paul') #加入到指定位置
     
    #从list删除元素
    L.pop() #pop()方法总是删掉list的最后一个元素，并且它还返回这个元素
    pop(2) #删除指定位置元素
     
    #替换元素
     L[2] = 'Paul' #对list中的某一个索引赋值。就能够直接用新的元素替换掉原来的元素
      
    #---------------------------------------------------
    #tuple是另一种有序的列表，中文翻译为“ 元组 ”。

    tuple 和 list 非常相似，可是，tuple一旦创建完成，就不能改动了。

     
    #创建tuple
    t = ('Adam', 'Lisa', 'Bart') #创建tuple和创建list唯一不同之处是用( )替代了[ ]
     
    #获取 tuple 元素的方式和 list 是一模一样的
     
    #包括 0 个元素的 tuple，也就是空tuple。直接用 ()表示
    t = () #打印()
     
    #创建包括1个元素的 tuple 
    t = (1,) #打印(1,)，加上“，”是由于()既能够表示tuple。又能够作为括号表示运算时的优先级，结果 (1) 被Python解释器计算出结果 1，导致我们得到的不是tuple。而是整数 1。
     
    #“可变”的tuple
    t = ('a', 'b', ['A', 'B']) #当我们把list的元素'A'和'B'改动为'X'和'Y'后,tuple一開始指向的list并没有改成别的list，所以。tuple所谓的“不变”是说，tuple的每一个元素，指向永远不变。

    Dict和Set类型

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    #花括号 {} 表示这是一个dict。然后依照 key: value, 写出来就可以。最后一个 key: value 的逗号能够省略。

    由于dict也是集合。len() 函数能够计算随意集合的大小

    d = {
        'Adam': 95,
        'Lisa': 85,
        'Bart': 59
    }
     
    #訪问dict 
    print d['Adam']
    #假设key不存在，会直接报错：KeyError。

    能够先推断一下 key 是否存在再取值

    if 'Paul' in d:
        print d['Paul']
    #也能够使用dict本身提供的一个 get 方法。在Key不存在的时候，返回None
    print d.get('Bart') #59 
    print d.get('Paul') #None
     
    #dict的特点
    #dict的第一个特点是查找速度快。不管dict有10个元素还是10万个元素，查找速度都一样(而list的查找速度随着元素添加而逐渐下降。

    只是dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费非常多内容，list正好相反。占用内存小。可是查找速度慢。

    )

    #由于dict是按 key 查找，所以。在一个dict中，key不能反复。

     
    #dict的第二个特点就是存储的key-value序对是没有顺序的
    #dict的第三个特点是作为 key 的元素必须不可变。Python的基本类型如字符串、整数、浮点数都是不可变的，都能够作为 key。可是list是可变的，就不能作为 key
     
    #更新dict
    d['Paul'] = 72 #假设 key 已经存在。则赋值会用新的 value 替换掉原来的 value
     
    #遍历dict
    d = {
        'Adam': 95,
        'Lisa': 85,
        'Bart': 59
    }
    for name in d:
        print name,':',d[name]
     
    #---------------------------------------------------
    #set 持有一系列元素。这一点和 list 非常像，可是set的元素没有反复，并且是无序的。这点和 dict 的 key非常像。
    #创建
    s = set(['A', 'B', 'C'])
     
    #訪问set
    #由于set存储的是无序集合，所以我们没法通过索引来訪问。

    訪问 set中的某个元素实际上就是推断一个元素是否在set中。

    'Bart' in s #返回True/False.（大写和小写敏感）
     
    #set的特点
    #set的内部结构和dict非常像，唯一差别是不存储value。因此，推断一个元素是否在set中速度非常快。
    #set存储的元素和dict的key相似，必须是不变对象。因此，不论什么可变对象是不能放入set中的。

    #最后，set存储的元素也是没有顺序的。
     
    #遍历set
    s = set(['Adam', 'Lisa', 'Bart'])
    for name in s:
        print name
         
    #更新set
    s.add(4) #元素已经存在于set中。add()不会报错。可是不会加进去了
    s.remove(4) #元素不存在set中，remove()会报错。所以remove()前须要推断。

    条件推断和循环

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    #if语句
    age = 20
    if age >= 118:
        print 'your age is', age
        print 'adult'
    else:
        print 'your age is', age 
    print 'END'
    # Python代码的缩进规则。

    具有同样缩进的代码被视为代码块

    # 缩进请严格依照Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格，否则非常容易造成由于缩进引起的语法错误。
     
    #if-elif-else
    age = 12
    if age >= 18:
        print 'adult'
    elif age >= 6:
        print 'teenager'
    elif age >= 3:
        print 'kid'
    else:
        print 'baby'
    # 这一系列条件推断会从上到下依次推断，假设某个推断为 True，运行完相应的代码块，后面的条件推断就直接忽略，不再运行了。

    (和Java一样)

     
    #for循环 遍历一个list或tuple
    L = ['Adam', 'Lisa', 'Bart']
    for name in L:
        print name
         
    #while循环
    N = 10
    x = 0
    while x < N:
        print x
        x = x + 1
     
    #（都和Java一样使用方法）
    #能够使用break退出循环 
    #continue继续循环
    #多重循环 
    for x in ['A', 'B', 'C']:
        for y in ['1', '2', '3']:
            print x + y

    函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    #能够直接从Python的官方站点查看文档： http://docs.python.org/2/library/functions.html#ab
    #调用函数
    print abs(-2) #2 
     
    #编写函数
    #在Python中，定义一个函数要使用 def 语句。依次写出函数名、括号、括号里的參数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。
    def my_abs(x):
        if x >= 0:
            return x
        else:
            return -x
    #假设没有return语句，函数运行完成后也会返回结果，仅仅是结果为None。

    return None能够简写为return。

     
    #递归函数
    def fact(n):
        if n==1:
            return 1
        return n * fact(n - 1)
    #分析（非常清晰）
    ===> fact(5)
    ===> 5 * fact(4)
    ===> 5 * (4 * fact(3))
    ===> 5 * (4 * (3 * fact(2)))
    ===> 5 * (4 * (3 * (2 * fact(1))))
    ===> 5 * (4 * (3 * (2 * 1)))
    ===> 5 * (4 * (3 * 2))
    ===> 5 * (4 * 6)
    ===> 5 * 24
    ===> 120
    #（扩展）使用递归函数须要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这样的数据结构实现的，每当进入一个函数调用，
    #栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以。递归调用的次数过多。会导致栈溢出。能够试试计算 fact(10000)。
     
    #定义默认參数 函数的默认參数的作用是简化调用
    def power(x, n=2):
        s = 1
        while n > 0:
            n = n - 1
            s = s * x
        return s
     
    print power(5)
    #由于函数的參数按从左到右的顺序匹配，所以默认參数仅仅能定义在必需參数的后面：
    # OK:
    def fn1(a, b=1, c=2):
        pass
    # Error:
    def fn2(a=1, b):
        pass
         
    #定义可变參数
    def fn(*args):
        print args
    #Python解释器会把传入的一组參数组装成一个tuple传递给可变參数，因此，在函数内部，直接把变量 args 看成一个 tuple 就好了。


    切片

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    #取前3个元素
    L = ['Adam', 'Lisa', 'Bart', 'Paul']
    L[0:3] #['Adam', 'Lisa', 'Bart']
    L[1:3] #['Lisa', 'Bart']
    L[:] #表示从头到尾
    L[::2] #第三个參数表示每N个取一个。L[::2]表示每两个元素取出一个来
     
    #倒序切片
    L = ['Adam', 'Lisa', 'Bart', 'Paul']
    L[-2:] #['Bart', 'Paul']
    L[:-2] #['Adam', 'Lisa']
    L[-3:-1] #['Lisa', 'Bart'] 倒数第三个開始切到倒数第一个
    L[-4:-1:2] #['Adam', 'Bart']
     
    #tuple和字符切片也是一样的，仅仅是返回的是tuple和字符

    迭代

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    #普通迭代  for ... in完成
     
    #索引迭代
    L = ['Adam', 'Lisa', 'Bart', 'Paul']
    for index, name in enumerate(L):
        print index, '-', name
    #0 - Adam
    #1 - Lisa
    #2 - Bart
    #3 - Paul
     
    #扩展
    #实际上。enumerate() 函数把：['Adam', 'Lisa', 'Bart', 'Paul'] 变成了相似： [(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]
    #因此。迭代的每一个元素实际上是一个tuple：
    for t in enumerate(L):
        index = t[0]
        name = t[1]
        print index, '-', name
    #假设我们知道每一个tuple元素都包括两个元素。for循环又能够进一步简写为：
    for index, name in enumerate(L):
        print index, '-', name
    #这样不但代码更简单。并且还少了两条赋值语句。
     
    #迭代dict的value
    #dict 对象有一个 values() 方法。这种方法把dict转换成一个包括全部value的list
    d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
    print d.values()
    # [85, 95, 59]
    for v in d.values():
        print v
    # 85
    # 95
    # 59
     
    #扩展 
    #假设细致阅读Python的文档，还能够发现，dict除了values()方法外。另一个 itervalues() 方法，用 itervalues() 方法替代 values() 方法，迭代效果全然一样：
    d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
    print d.itervalues()
    # <dictionary-valueiterator object at 0x106adbb50>
    for v in d.itervalues():
        print v
    # 85
    # 95
    # 59
    #那这两个方法有何不同之处呢？
    #1. values() 方法实际上把一个 dict 转换成了包括 value 的list。

    #2. 可是 itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。
    #3. 打印 itervalues() 发现它返回一个 <dictionary-valueiterator> 对象。这说明在Python中，for 循环可作用的迭代对象远不止 list，tuple，str。unicode，dict等。不论什么可迭代对象都能够作用于for循环。而内部怎样迭代我们通常并不用关心。
    #假设一个对象说自己可迭代。那我们就直接用 for 循环去迭代它。可见。迭代是一种抽象的数据操作，它不正确迭代对象内部的数据有不论什么要求。
     
    #迭代dict的key和value
    for key, value in d.items():
        print key, ':', value
     
    #Lisa : 85
    #Adam : 95
    #Bart : 59
    # values() 有一个 itervalues() 相似。items() 也有一个相应的 iteritems()，iteritems() 不把dict转换成list，而是在迭代过程中不断给出 tuple，所以。 iteritems() 不占用额外的内存。

    列表生成式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    #要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，我们能够用range(1, 11)：
    #但假设要生成[1x1, 2x2, 3x3, ..., 10x10]怎么做
    L = []
    for x in range(1, 11):
        L.append(x * x)
    #还能够用
    [x * x for x in range(1, 11)] #这样的写法就是Python特有的列表生成式。

    利用列表生成式。能够以非常简洁的代码生成list

     
    #条件过滤 假设我们仅仅想要偶数的平方，不改动 range()的情况下，能够加上 if 来筛选：
    [x * x for x in range(1, 11) if x % 2 == 0] #有了 if 条件，仅仅有 if 推断为 True 的时候，才把循环的当前元素加入到列表中。
    #[4, 16, 36, 64, 100]
     
    #多层表达式
    [m + n for m in 'ABC' for n in '123']
    #['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
    #相当于
    L = []
    for m in 'ABC':
        for n in '123':
            L.append(m + n)

    參考

            慕课网
  • 相关阅读:
    Codeforces Bubble Cup 8
    Codeforces Bubble Cup 8
    BZOJ 2588: Spoj 10628. Count on a tree 树上跑主席树
    hdu 5279 Reflect phi 欧拉函数
    hdu 5278 Geometric Progression 高精度
    hdu 5428 The Factor 分解质因数
    hdu 5427 A problem of sorting 水题
    Codeforces Gym 100610 Problem A. Alien Communication Masterclass 构造
    Codeforces Gym 100610 Problem K. Kitchen Robot 状压DP
    Codeforces Gym 100610 Problem H. Horrible Truth 瞎搞
  • 原文地址：https://www.cnblogs.com/cxchanpin/p/7162120.html
Copyright © 2011-2022 走看看