python基础语法

作者: 网络编程  发布:2019-08-08

在Computer程序的付出进度中,随着程序代码越写越来越多,在叁个文件里代码就能越来越长,更加的不轻松保险。

缩进错误会油然则生如下报错:

"""

空行:

单行:# 
多行:三个'单引号'或三个"双引号"

 

break和continue语句及循环中的else子句

一、break 语句能够跳出 for 和 while 的循环体。借使您从 for 或 while 循环中甘休,任何对应的循环 else 块将不进行。

例:

for letter in 'frank-me': # 第叁个实例
    if letter == '-':           # 当符号为“-”时,跳出
        break
    print ('当前字符为 :', letter)

var = 10 # 第四个实例
while var > 0:
    print ('当期变量值为 :', var)
    var = var -1
    if var == 5:               # 到数字5(包蕴5)时不往下实行
        break

print ("See you!")

# 输出结果:

眼前字符为 : f
脚下字符为 : r
此时此刻字符为 : a
现阶段字符为 : n
日前字符为 : k
当期变量值为 : 10
当期变量值为 : 9
当期变量值为 : 8
当期变量值为 : 7
当期变量值为 : 6
See you!

二、continue语句被用来告诉Python跳过当前循环块中的剩余语句,然后继续开始展览下一轮循环。

例:

for letter in 'frank-me': # 第三个实例
    if letter == '-': # 字符为 "-" 时跳过输出,继续往下施行
        continue
    print ('当前字符 :', letter)

var = 10 # 第3个实例
while var > 0:
    var = var -1
    if var == 5: # 变量为 5 时跳过输出,继续往下实施
        continue
    print ('当前变量值 :', var)
print ("See you!")

# 输出结果:

脚下字符 : f
此时此刻字符 : r
现阶段字符 : a
日前字符 : n
当前字符 : k
当下字符 : m
脚下字符 : e
此时此刻变量值 : 9
如今变量值 : 8
近期变量值 : 7
眼前变量值 : 6
脚下变量值 : 4
此时此刻变量值 : 3
现阶段变量值 : 2
前段时间变量值 : 1
日前变量值 : 0
See you!

三、循环语句能够有 else 子句,它在穷尽列表(以for循环)或标准成为 false (以while循环)导致循环终止时被执行,但循环被break终止时不试行。

例:

for i in range(2, 10):
    for x in range(2, i):
        if i % x == 0:
            print(i, '=', x, '*', i//x)
            break
    else:
    # 循环中一直不找到成分
    print(i, '是质数')

# 输出结果:

2 是质数
3 是质数
4 = 2 * 2
5 是质数
6 = 2 * 3
7 是质数
8 = 2 * 4
9 = 3 * 3

 

for-else

 

for中从未break,则else一定会进行

for temp in strs: 

   print(temp)   

else: 

   print("")

 

const 修改变量为不可变。

 

(pass语句)

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

pass 不做其他交事务情,一般用做占位语句。

while True:
    pass # 等待键盘中断 (Ctrl C)

微小的类:

class EmptyClass:
    pass

例:

for letter in 'frank-me':
    if letter == '-':
        pass
    print ('- 执行 pass')
print ('当前字符 :', letter)

print ("See you!")

# 输出结果:

时下字符 : f
此时此刻字符 : r
近日字符 : a
眼下字符 : n
日前字符 : k

  • 执行 pass
    脚下字符 : -
    时下字符 : m
    现阶段字符 : e
    See you!

11.字符串(不可变)

一、创建
       ‘ str ’,“ str ”单引号或双引号包裹起来的源委
       顺序,序列
           -- 偏移量,索引,直标
       长度
           --len()重返一个连串的长短
       ** 单个字符,即长度为1的字符串

二、索引
       test_str[0]
       ** 非常的:最后一成分的目录“-1”,“-2”代表尾数第二,就那样类推
       切片
           -- test_str[strat:end]
           -- start:发轫索引(满含那个成分)
           -- end:甘休索引(不包括这么些因素)
           -- start < end
       不可变
           -- 无法改改

切片例:

str = "dasfaf"

str[2:4] #(取得2到3的), 

str[2:]  #(到最后), 

str[2:-1:2] #(步长2,隔三个取一个)

逆序:

str = "abcdefABCDEF" 

str[0:]  # out:"abcdefABCDEF" (顺序)

str[-1:]  # out:"F" (尾数第三个)

str[-1:0]  # out:"" 

str[-1:0:-1]  # out:"FED中职篮fedcb" (逆序,不含第二个)

str[-1::-1], str[::-1]  # out:"FEDCBAfedcba"(逆序

 

三、字符串连接:

a = b c  #或者

a = "===%s==="%(b c)  #或者

a = "==={}===".format(b c)

四、常见操作

find: str.find("abc")  # 从左向右有重返第一个相称字符串的序曲下标,未有回去-1。rfind():从右向左。 

str.index("abc")  #找到重临伊始下标,未有抛出非常。 存在rindex(). 

str.count("abc")  #相配的个数。

 

str.replace("abc", "def")  #同java,把右手的替换来右侧的 。

str.replace("abc", "def",1)  #其五个参数是从左到右替换个数。 

 

str.split(" ")  #同java ,通过点名分隔符(包涵空格、换行(n)、制表符(t)等)对字符串举行切开,如若参数 num 有内定

          值,则仅相隔 num 个子字符串。

str.capitalize()  #字符串的率先个字母大写。 

str.title()  #字符串的种种单词的首字母大写。 

str.startswith("abc"), str.endswith("abc")  #同java,用于检查字符串是还是不是是以钦赐子字符串伊始,若是是则赶回 True,

                            不然赶回 False。若是参数 beg 和 end 钦定值,则在钦命范围内检查。

str.lower() str.uper()  #全体的假名小写和题诗。 

str.center(50)  #从中展现,行总局长50 "     abc     "

str.ljust(50), str.rjust(50)  #左(右)对齐

 

str.lstrip()  #删去右边空格

str.rstrip()  #左侧空格

str.strip()  #去除两端空格.

12.列表 (类似数组,可变,针对自个儿的成形)

运算符

表达式

结果

描述

len([1, 2, 3])

3

测算成分个数

[1, 2, 3] [4, 5, 6]

[1, 2, 3, 4, 5, 6]

连接

[‘Hi!’] * 4

[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]

复制

3 in [1, 2, 3]

True

要素是或不是存在

for x in [1, 2, 3]: print(x, end=” “)

1 2 3

迭代

创建
    序列
    list1 = [1,2,3,4,5,6]

例:

["zhangsan","lisi"]

#定义

names = ["zhangsan", "lisi", 3.14]  #列表中的数据能够是例外的数据类型。  可以下标,和切成片。

增加和删除改查

   
    -- 1.list.append(item)向尾部增添
    -- 2.list.insert(index,item) 向内定的地点插入

例:#增

names.append("abc") #-->插入到结尾; 

names.insert(0, "bcc") #-->插入钦赐地点。 

names = names1 names2 #七个列表用连接符

names1.extend(names2) #扩充

#专注:append增添的元素;extend连接的列表

   
    -- list.pop(index)  #-->index 暗中同意-1 (最终三个)

例:#删

names.pop() #-->删除最后二个; 

names.remove("lisi") #-->依照剧情删除; 

del names[0] #-->下标删除

   

    -- 直接复制

例:#改

names[0] = "abc" 

   
    索引
    操作同字符串

例:#查

name[1:] # "lisi"

in, not in #是或不是留存 (if "zhangsan" in names:) 

#能够for... in 循环遍历

len(names) #要素个数 

 

13.字典(可变)

a = {"name":"yy", "age": 12}

 

a["name"] = "yy" #直接写key-value 

del a["name"]

a["name"] = "zz" #同样key的值覆盖。

a["name"], a.get("name")

例:

>>> params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
>>> params
{'server': 'mpilgrim', 'database': 'master', 'uid': 'sa', 'pwd': 'secret'}

>>> ["%s=%s" % (k, v) for k, v in params.items()]
['server=mpilgrim', 'database=master', 'uid=sa', 'pwd=secret']

>>> ";".join(["%s=%s" % (k, v) for k, v in params.items()])
'server=mpilgrim;database=master;uid=sa;pwd=secret'

 

 
字典常见操作

len(params) #键值对的个数

 

params.keys() 或 dict.keys(params) #返回key的列表

if "uid" in params.keys(): #看清是还是不是存在有个别key

    print("yes")

params.values() #返回value的列表

 

14.元组(类似列表,不可变)

列表能够增加和删除改,元组不能够改

tup1 = (); #空元组

例:

>>> tup1 = (50)

>>> type(tup1)     # 不加逗号,类型为整型

# 实行结果:

<class 'int'>

 

>>> tup1 = (50,)

>>> type(tup1)     # 加上逗号,类型为元组

# 实施结果:

<class 'tuple'>

 

访问:

例:

tup1 = ('Google', 'Baidu', 1997, 2000)

tup2 = (1, 2, 3, 4, 5, 6, 7 )

 

print ("tup1[0]: ",tup1[0])

# 实施结果:

tup1[0]:  Google

 

print ("tup2[1:5]: ", tup2[1:5])

# 实践结果:

tup2[1:5]:  (2, 3, 4, 5)

 

修改:

例:

tup1 = (12, 34.56);

tup2 = ('abc', 'xyz')

 

# 以下修改元组成分操作是专擅的。

# tup1[0] = 100

 

# 创造一个新的元组

tup3 = tup1 tup2;

print (tup3) #(12, 34.56, 'abc', 'xyz')

 

删除

tup = ('Google', 'Baidu', 1997, 2000)

 

print (tup)

del tup;

 

就像拆包

a = (11,12)

b = a

b #out (11,12)

c,d = a #好像拆包

c #out 11

d #out 12

 

例:

info = {"name":"ysw", "age":24}

for temp in info:

    print(temp)

# 实行结果:

name

 age

 

for temp in info.items():

    print("key=%s,value=%s"%(temp[0],temp[1]))

#or(或者)

for a,b in info.items():

    print("key=%s,value=%s"%(a,b))

# 实践结果

key=name,value=ysw
key=age,value=24

 

遍历技巧

一、在字典中遍历时,关键字和对应的值能够选用 items() 方法同期解读出来

knights = {'gallahad': 'the pure', 'robin': 'the brave'}

for k, v in knights.items():

          print(k, v)

 

# 试行结果:

gallahad the pure

robin the brave

 

二、在种类中遍历时,索引地方和对应值能够行使 enumerate() 函数同不经常候获得

>>> for i, v in enumerate(['tic', 'tac', 'toe']):

...     print(i, v)

 

# 推行结果:

0 tic

1 tac

2 toe

 

三、同偶然间遍历七个或更加多的类别,能够采用 zip() 组合

>>> questions = ['name', 'quest', 'favorite color']

>>> answers = ['lancelot', 'the holy grail', 'blue']

>>> for q, a in zip(questions, answers):

...     print('What is your {0}?  It is {1}.'.format(q, a))

...

# 施行结果:

What is your name?  It is lancelot.

What is your quest?  It is the holy grail.

What is your favorite color?  It is blue.

 

四、要反向遍历一个队列,首先钦赐这几个队列,然后调用 reversed() 函数

>>> for i in reversed(range(1, 10, 2)):

...     print(i)

...

# 施行结果:

9

7

5

3

1

 

五、要按顺序遍历四个队列,使用 sorted() 函数再次来到三个已排序的连串,并不修改原值

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']

>>> for f in sorted(set(basket)):

...     print(f)

...

# 推行结果:

apple

banana

orange

pear

 

15.函数

def abc():

    print("")

 

abc()

#留神: 函数的定义须求在函数的调用从前,否则报错。

可更动与不足更动对象: 
在python中,strings,tuples和numbers是不行改造对象,list.dict等则是可更换对象。 

  • 不行变类型:变量赋值 a=5后在赋值a=10,生成了新的目的,原对象扬弃。 
  • 可变类型:变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第七个成分值改变,本人la没有动,只是个中间的一部分值被修改了。

python 函数的参数字传送递: 

  • 不足变类型:类似 c 的值传递,如 整数、字符串、元组。如fun(a),传递的只是a的值,未有影响a对象自己。比方在 fun(a)内部修改 a 的值,只是修改另一个复制的目的,不会潜濡默化 a 本人 
  • 可变类型:类似 c 的引用传递,如 列表,字典。如 fun(la),则是将 la 真正的传过去,修改后fun外界的la也会受影响

 

一、私下认可函数参数 

def printinfo( name, age = 35 ):

   "打字与印刷任何传入的字符串"

   print ("名字: ", name);

   print ("年龄: ", age);

   return;

 

printinfo( age=50, name="baidu" );

print ("------------------------")

printinfo( name="baidu" );

 

 # 推行结果:

名字:  baidu

年龄:  50


名字:  baidu

年龄:  35

 

二、可变参数

例:

def printinfo( *vartuple ):

   "打字与印刷任何传入的参数"

   print ("输出: ")

   for var in vartuple:

      print (var)

   return;

 

printinfo(10,32,22)

 

#佚名函数(lambda创立佚名函数)

 

sum = lambda arg1, arg2: arg1 arg2;

 

print ("相加后的值为 : ", sum( 10, 20 ))

print ("相加后的值为 : ", sum( 20, 20 ))

 

# 实施结果:

输出:
10
32
22
相加后的值为 : 30
相加后的值为 : 40

 

三、global关键字修改外界作用域变量

例:

num = 1

def fun1():

    global num  # 需求使用 global 关键字注解

    print(num)

    num = 123

    print(num)

fun1()

#  推行结果:

1

123

 

四、nonlocal 修改嵌套成效域变量

例:

def outer():

    num = 10

    def inner():

        nonlocal num   # nonlocal关键字注解

        num = 100

        print(num)

    inner()

    print(num)

outer()

 

# 实行结果:

100

100

 

16.迭代器和生成器

一、字符串,列表和元组对象都可用于成立迭代器。

例:

list = [1,2,3,4]

it = iter(list)

print(next(it)) 

print(next(it)) 

 

#推行结果

1

2

 

for x in it:  #遍历

    print(x, end = "")

#施行结果:

1 2 3 4

 

 例:

import sys

list = [1,2,3,4]

it = iter(list)

while True:

    try:

        print(next(it))

    except StopIteration:

        sys.exit()

# 推行结果:

1

2

3

4

 

二、生成器(TODO) 

yield 的函数,生成器是回到迭代器的函数,只好用于迭代操作。

例:

import sys

 

def fibonacci(n): # 生成器函数 - 斐波那契

    a, b, counter = 0, 1, 0

    while True:

        if (counter > n):

            return

        yield a               # 相当于generator的print(a)

        a, b = b, a b   # 注意,赋值语句也就是:t = (b,a b), t 是一个tuple,a = t[0] , b = t[1]

        counter = 1

f = fibonacci(10) # f 是一个迭代器,由生成器重返生成

 

while True:

    try:

        print (next(f), end=" ")

    except StopIteration:

        sys.exit()

 

#奉行结果:

0 1 1 2 3 5 8 13 21 34 55

 

17.模块

 Python 提供了二个艺术,把一些定义贮存在文件中,为一些本子只怕交互式的解释器实例使用,那么些文件被称之为模块。 

  • import语句,想采用 Python 源文件,只需在另三个源文件里实施 import 语句。

例:

#!/usr/bin/python3

# Filename: support.py

 

def print_func( par ):

    print ("Hello : ", par)

    return

 

#!/usr/bin/python3

# Filename: test.py

 

 

import support #导入模块,即文件名

 

# 未来能够调用模块里带有的函数了

support.print_func()

 

from…import语句,从模块中程导弹入一个点名的部分到日前定名空间中。

#导入模块 fibo 的 fib 函数

from fibo import fib, fib2

>>> fib(500)

  • From…import* 语句,把贰个模块的具有内容全都导入到当前的命名空间。
  • 模块除了艺术定义,还是能归纳可奉行的代码。那么些代码一般用来起首化那一个模块。这一个代码独有在首先次被导入时才会被实行。
  • name属性,贰个模块被另二个顺序第一遍引进时,其主程序将运营。若是大家想在模块被引进时,模块中的某一程序块不实行,能够用name属性。

例:

#!/usr/bin/python3

# Filename: using_name.py

 

if __name__ == '__main__':

   print('程序自个儿在运作')

else:

   print('作者来自另一模块')

 

#实践结果:

先后自己在运行

 

  • Python 会依据 sys.path 中的目录来搜索这一个包中富含的子目录。
  • 目录独有包罗二个叫做 init.py 的文本才会被认作是二个包,首假如为了幸免某些滥俗的名字(譬如叫做 string)非常的大心的熏陶寻觅路线中的有效模块。
  • 推荐:from Package import specific_submodule

18.文件

open()方法再次回到文件,第二个参数为文件张开药格局。私下认可只读r / 写w,a追加…

f = open("/tmp/test.txt","w")

 

f.write("人生苦短,作者用python!")

 

f.close()

  • f.read(size) 读取文件内容,size为空或负数则全部回来。
  • f.readline() 会从文件中读取单独的一条龙。换行符为 ‘n’。f.readline() 假如回去一个空字符串, 表达已经已经读取到最后一行。
  • f.readlines() 读取文件全体行,并以列表再次来到。
  • f.write(string) 将 string 写入到文件中, 然后归来写入的字符数。如若要写入一些不是字符串的事物, 那么将急需先实行更动。

19.类

类方法

例:

class MyClass:

    i = 12345

    #类措施必须有贰个十二分的首先个参数,惯例是self,不稳固;代表的的类的实例而非类

    def f(self):

        return "hello world"

 

x = MyClass()

print("MyClass 类的性质 i 为:", x.i)

print("MyClass 类的不二诀窍 f 输出为:", x.f())

 

#进行理并了结果:

MyClass 类的属性 i 为: 12345
MyClass 类的秘诀 f 输出为: hello world

 

构造方法

例:

class Complex:

    #构造方法

    def __init__(self, realpart, imagpart):

        self.r = realpart

        self.i = imagpart

x = Complex(3.0, -4.5)

print(x.r, x.i)  

 

# 试行结果:

3.0 -4.5

 

例: 

类定义

class people:

    #概念基本性能

    name = ''

    age = 0

    #概念私有属性,私有属性在类外部不或者直接开展会见

    __weight = 0

#概念构造方法

    def __init__(self,n,a,w):

        self.name = n

        self.age = a

        self.__weight = w

    def speak(self):

        print("%s 说: 我 %d 岁。" %(self.name,self.age))

 

# 实例化类

p = people('baidu',10,30)

p.speak()

 

 # 实行结果:

baidu 说: 我 10 岁。

 

继承

例:

类定义

class people:

    #概念基特性子

    name = ''

    age = 0

    #概念私有属性,私有属性在类外界无法直接开始展览拜见

    __weight = 0

    #概念构造方法

    def __init__(self,n,a,w):

        self.name = n

        self.age = a

        self.__weight = w

    def speak(self):

        print("%s 说: 我 %d 岁。" %(self.name,self.age))

 

#单承接示例

class student(people):

    grade = ''

    def __init__(self,n,a,w,g):

        #调用父类的构函

        people.__init__(self,n,a,w)

        self.grade = g

    #覆写父类的艺术

    def speak(self):

        print("%s 说: 我 %d 岁了,我在读 %d 年级"%(self.name,self.age,self.grade))

 

#另三个类,多种承袭以前的计划

class speaker():

    topic = ''

    name = ''

    def __init__(self,n,t):

        self.name = n

        self.topic = t

    def speak(self):

        print("作者叫 %s,小编是一个解说家,笔者发言的大旨是 %s"%(self.name,self.topic))

 

#多种承袭

class sample(speaker,student):

    a =''

    def __init__(self,n,a,w,g,t):

        student.__init__(self,n,a,w,g)

        speaker.__init__(self,n,t)

 

test = sample("frank",25,80,4,"Python")

test.speak()   #主意名同,暗中认可调用的是在括号中排前地父类的格局

 

# 试行结果:

自己叫 frank,笔者是三个解说家,我发言的主旨是 Python

 

20.正则表明式

      re.match与re.search的区别 
      re.match只相配字符串的初步,纵然字符串初阶不适合正则表明式,则极度退步,函数重回None;而re.search相配整个字符串,直到找到一个相配。

例:

import re

 

line = "Cats are smarter than dogs";

matchObj = re.match( r'dogs', line, re.M|re.I)

if matchObj:

   print ("match --> matchObj.group() : ", matchObj.group())

else:

   print ("No match!!")

 #进行结果

   No match!!

 

例:

import re

 

line = "Cats are smarter than dogs";

matchObj = re.search( r'dogs', line, re.M|re.I)

if matchObj:

   print ("search --> matchObj.group() : ", matchObj.group())

else:

   print ("No match!!")

 #施行结果

   search --> matchObj.group() :  dogs

 

查找和替换

例:

import re

phone = "2018-666-666 # 那是二个电话号码" 

num = re.sub(r'#.*$', "", phone)   # 删除“#”前边的批注内容

print ("电话号码 : ", num)

 

#施行结果

电话号码 :  2018-666-666 

 

例:

import re

phone = "2018-666-666 # 那是五个电话号码" 

num = re.sub(r'D', "", phone) # 移除非数字的源委

print ("电话号码 : ", num)

 

#进行结果

电话号码 :  2018666666

 

最后用一张图来归纳:

图片 1

IndentationError: unexpected indent 错误是 python 编写翻译器是在报告您"Hi,老兄,你的文件里格式不对了,大概是tab和空格没对齐的标题",全数 python 对格式须要十二分严酷。

python2 = assic =  不援助中文

>>> import keyword

总结:

模块是一组Python代码的联谊,能够使用别的模块,也能够被别的模块使用。

始建谐和的模块时,要专注:

  • 模块名要服从Python变量命名规范,不要使用中文、特殊字符;
  • 模块名不要和系统模块名争执,最棒先查看系统是不是已存在该模块,检查情势是在Python交互意况实行import abc,若成功则表达系统存在此模块。

 

4.输入

name = input("请输入名字:")

5.输出

print("name is %s"%name)  

print("name:%s, age:%d"%(name,age)) 

print("name:{0}, age:{1}".format(name,age)) #(标号可不写,为暗许顺序)

print("name:{name}, age:{age}".format(name = "你的名字",age = 60))

 

import math

print('常量 PI 的值近似为 {0:.3f}。'.format(math.pi)) #常量 PI 的值近似为 3.142。

 

table = {'tbl_a': 1, 'tbl_b': 2, 'tbl_c': 3}

print('tbl_b: {0[tbl_b]:d}; tbl_a: {0[tbl_a]:d}; tbl_c: {0[tbl_c]:d}'.format(table))

#tbl_b: 2; tbl_a: 1; tbl_c: 3

 

table = {'tbl_a': 1, 'tbl_b': 2, 'tbl_c': 3}

print('tbl_b: {tbl_b:d}; tbl_a: {tbl_a:d}; tbl_c: {tbl_c:d}'.format(**table))

#tbl_b: 2; tbl_a: 1; tbl_c: 3

6.类型调换

a = int("100")  # 转变为数字

a = str("100“)  # 调换为字符串

7.python2与python3

python第22中学input的剧情作为推行的剧情,python3当做字符串。如a = input(“”). python第22中学的raw_input相当于python3中的inpout。

python2 中支持 <> 是不等于的意趣,python3不支持,应该用 != 表示

8.运算符

一、算述运算符:

1 1 = 2 (加法)

4 - 10 = -6 #(减法 - 得到负数或是贰个数减去另三个数)

"a" * 5 = "aaaaa" #(乘法 - 八个数相乘或是重回一个被重新若干次的字符串)

2 ** 3 = 8 #(幂 - 返回2的3次幂)

5 / 2 = 2.5 #(除法)

5 // 2 = 2 #(取商 - 再次回到商的整数部分)

5 % 2 = 1 #(取余 - 重返除法的余数)

二、赋值运算符:

i = 1   等价于 i = i 1
i  -= 1   等价于 i = i - 1
i  *= 2   等价于 i = i * 2
i  /= 2   等价于 i = i / 2
i  //= 2  等价于 i = i // 2
i  %= 2 等价于 i = i % 2
i  **= 2 等价于 i = i ** 2

9.逻辑运算符

not , and , or

优先级(短路原则):

and:条件1 and 准则2 ,假若条件1为假,那么这一个and前后四个规格构成的表明式的计算结果就势必为假,就不判定标准2了

  or:条件1 or 规范化2,假诺前方的首先个规格为真,那么那一个or前后多少个标准构成的表达式的计算结果就势必为真,就不衡量规范2了

10.流程

**表达式**操作运算符、常量及变量:

(1)表明式:由操作数和平运动算符组成的一句代码或言辞,表明式能够求值,能够放在" = "的左侧,用来给变量赋值。

(2)操作运算符:

<  小于

<=  小于或等于

>  大于

>=  大于或等于

==  等于,比较对象是或不是等于(注意区分 = ,= 是赋值,==是相比较)

!=  不等于

(3)常量:固定不改变的量,字母大写

(4)变量: 存款和储蓄音讯,现在被调用

取名准则:

    • 1.字母数字下划线组成
    • 2.不能以数字初步,无法含有特殊字符和空格
    • 3.不可能以保留字命名
    • 4.不能以汉字命名
    • 5.定义的变量名应该有含义
    • 6.驼峰式命名、下划线分割单词

    • 7.变量名分别轻重缓急写

(if...elif...else)

if 条件(如果): 

elif 条件(或如果):  

else否则:

图片 2

注意:

  • 1、每种条件前边要选取冒号 :,表示接下去是满意条件后要实践的语句块。
  • 2、使用缩进来划分语句块,一样缩进数的言辞在一同组成一个语句块。
  • 3、在Python中没有switch – case语句。

例:

# 该实例演示了数字猜谜游戏
number = 7
guess = 0
print("数字猜谜游戏!")
while guess != number:
    guess = int(input("请输入你猜的数字:"))

    if guess == number:
        print("恭喜,你猜对了!")
    elif guess < number:
        print("猜的数字小了...")
    elif guess > number:
        print("猜的数字大了...")

# 施行结果:

数字猜谜游戏!
请输入你猜的数字:5
猜的数字小了...
请输入你猜的数字:6
猜的数字小了...
请输入你猜的数字:8
猜的数字大了...
请输入你猜的数字:9
猜的数字大了...
请输入你猜的数字:7
恭贺,你猜对了!

 

if 嵌套:在嵌套 if 语句中,能够把 if...elif...else 结构放在其他叁个if...elif...else 结构中。

 

if 表达式1:
    语句
    if 表达式2:
        语句
    elif 表达式3:
        语句
    else:
        语句
elif 表达式4:
    语句
else:
    语句

例:

num=int(input("输入一个数字:"))
if num%2==0:
    if num%3==0:
        print ("你输入的数字能够整除 2 和 3")
    else:
        print ("你输入的数字能够整除 2,但无法整除 3")
else:
    if num%3==0:
        print ("你输入的数字能够整除 3,但无法整除 2")
    else:
        print ("你输入的数字不可能整除 2 和 3")

 # 实行结果:

输入贰个数字:5
您输入的数字不可能整除 2 和 3

输入一个数字:6
您输入的数字能够整除 2 和 3

 

(while)

while 剖断规范: #(while:当...的时候)

    语句

一、要求注意冒号缩进。另外,在Python中没有do...while循环。

例:while 循环使用 else 语句

i = 0
while i < 5:
    print (i, " 小于 5")
    i = 1      # 变量自增
else:
    print (i, " 等于 5")

# 输出结果:

0 小于 5
1 小于 5
2 小于 5
3 小于 5
4 小于 5
5 等于 5

二、以下实例使用了 while 来总结 1 到 100 的总额:

i = 100
sum = 0
counter = 1
while counter <= i:
    sum = sum counter
    counter = 1
print("1 到 %d 之和为: %d" % (i,sum))

# 输出结果:

1 到 100 之和为: 5050

(for)

一、for循环能够遍历任何种类的品类,如四个列表只怕三个字符串。

例:

languages = ["C", "C ", "Perl", "Python"]
for x in languages:
print (x)

# 输出结果:

C
C
Perl
Python

二、以下 for 实例中采用了 break 语句,break 语句用于跳出当前循环体。

例:

sites = ["Baidu", "Google","frank-me","Taobao"]
for site in sites:
    if site == "frank-me":
        print("笔者的网站")
        break
print("循环数据 " site)
else:
    print("到此甘休!")
print("结束!")

 

# 输出结果:

巡回数据 Baidu
巡回数据 谷歌
自己的网站
结束!

注意: i , i 在python中不允许选择。

(range函数)

一、假让你需求遍历数字连串,能够选用内置range()函数,它会生成数列。

例:

for i in range(5):
print(i)

# 输出结果:

0
1
2
3
4

二、也足以选用range内定区间的值。

例:

for i in range(5,9) :
print(i)

# 输出结果:

5
6
7
8

三、也得以使range以内定数字开首并钦赐不一致的增量(乃至足以是负数,一时那也叫做'步长')。

例:

for i in range(0, 10, 3) :
print(i)

# 输出结果:

0
3
6
9

四、您能够整合range()和len()函数以遍历多个类别的目录

例:

>>> a = ['Google', 'Baidu', 'frank-me', 'Taobao', 'QQ']
>>> for i in range(len(a)):
>>> print(i, a[i])

# 输出结果:

0 Google

1 Baidu

2 frank-me

3 Taobao

4 QQ

五、能够运用range()函数来创立多少个列表,用for直接历遍

>>> for i in list(range(5)):

...         print( i )

# 输出结果:

0
1
2
3
4

Python3 字符串

字符串是 Python 中最常用的数据类型。大家得以采纳引号('或")来创建字符串。

创制字符串不会细小略,只要为变量分配一个值就能够。比方:

var1 = 'Hello World!' var2 = "Runoob"

 

Python 访谈字符串中的值

Python 不协理单字符类型,单字符也在Python也是用作一个字符串使用。

Python 访谈子字符串,可以选取方括号来截取字符串,如下实例:

var1 = 'Hello World!' var2 = "Runoob" print("var1[0]: ", var1[0])
print("var2[1:5]: ", var2[1:5])

实践结果:

var1[0]:  H

var2[1:5]:  unoo

 

Python字符串更新

您能够截取字符串的一有些并与另外字段拼接,如下实例:

var1 = 'Hello World!' print("已履新字符串 : ", var1[:6] 'Runoob!')

文件www.py的模块名正是mycompany.web.www,多少个文件utils.py的模块名分别是mycompany.utilsmycompany.web.utils

 

From 模块名 import 子模块1,子模块2,......

import 与 from...import...与import...as...

化解:程序首行加 #coding=utf-8 或 #*-* coding:utf-8 *-*

http://www.runoob.com/      新手教程

举个例证,三个abc.py的文书正是一个名字叫abc的模块,一个xyz.py的公文就是二个名字叫xyz的模块。

http://www.geany.org/Download/Releases

python3 = unicode = 暗中认可帮忙粤语

安装教程

'''

python保留字:

最大的益处是大大进步了代码的可维护性。其次,编写代码不必从零起初。当二个模块编写实现,就足以被其余地方引用。我们在编写程序的时候,也时时援用其余模块,蕴含Python内置的模块和来源第三方的模块。

一经是 IndentationError: unindent does not match any outer indentation level错误注明,你选用的缩进情势不雷同,有的是 tab 键缩进,有的是空格缩进,改为同样就可以。

为了编写制定可保险的代码,我们把比很多函数分组,分别放到不相同的文书里,那样,每种文件包蕴的代码就相对很少,相当多编制程序语言都接纳这种组织代码的艺术。在Python中,三个.py文件就叫做四个模块(Module)。

针对geany上有汉字报错的动静,请在每一次编制程序时在先后第一行打上#coding=gbk

引进了包之后,只要顶层的包名不与别人争论,那全体模块都不会与旁人顶牛。以往,abc.py模块的名字就产生了mycompany.abc,类似的,xyz.py的模块名改成了mycompany.xyz

Python的主旨!Python PEP 8提议每级缩进都施用多少个空格,那既可提升可读性,又留下了足足的点不清缩进空间。在字管理文书档案中,大家平日使用制表符并非空格来缩进。对于文字处理文书档案来讲,那样做的效劳很好,但混合使用制表符和空格会让Python解释器感觉迷惑。每款文本编辑器都提供了一种设置,可将输入的制表符调换为钦命数量的空格。你在编排代码时应有使用制表符键,但必然要对编辑器进行安装,使其在文书档案中插入空格实际不是制表符。在程序中混合使用制表符和空格大概导致极难消除的主题材料。如果您混合使用了制表符和空格,可将文件中保有的制表符转变为空格,大好些个编辑器都提供了这么的成效。(能够不看,缩进正是Tab键)

Import 模块名

getopt模块

getopt模块是极度管理命令行参数的模块,用于获取命令行选项和参数,也正是sys.argv。命令行选项使得程序的参数更灵活。帮助短选项格局(-)和长选项格局(--)。

该模块提供了多个办法及三个可怜管理来分析命令行参数。

明天,要是大家的abcxyz那三个模块名字与其他模块争辩了,于是大家得以由此包来集团模块,幸免争执。方法是挑选一个顶层包名,譬如mycompany,依据如下目录寄放:

Python3 运算符

何以是运算符?

本章节重大表达Python的运算符。举个轻巧的事例 4 5 = 9 。 例子中,4 和 5 被称为操作数," " 称为运算符。

Python语言帮助以下种类的运算符:

算术运算符

比较(关系)运算符

赋值运算符

逻辑运算符

位运算符

分子运算符

身价运算符

运算符优先级

接下去让大家三个个来读书Python的运算符。

http://www.jb51.net/list/list_97_1.htm    学习网址

print("hello world") 

 

请细心,每一个包目录下边都会有三个__init__.py的文件,那个文件是必须存在的,不然,Python就把那一个目录当成普通目录,并不是一个包。__init__.py能够是空文件,也足以有Python代码,因为__init__.py自家便是一个模块,而它的模块名正是mycompany

 

mycompany
 ├─ web
 │  ├─ __init__.py
 │  ├─ utils.py
 │  └─ www.py
 ├─ __init__.py
 ├─ abc.py
 └─ xyz.py

Python3 迭代器与生成器

'''

Python比较运算符

运算符

描述

实例

==

等于 - 相比较对象是还是不是等于

(a == b) 返回 False。

!=

不对等 - 比较五个目的是或不是不等于

(a != b) 返回 True。

>

不独有 - 再次来到x是还是不是大于y

(a > b) 返回 False。

<

紧跟于 - 重临x是或不是小于y。全体相比运算符再次来到1表示真,返回0表示假。那分别与新鲜的变量True和False等价。注意,那个变量名的大写。

(a < b) 返回 True。

>=

不仅等于 - 再次来到x是或不是超越等于y。

(a >= b) 返回 False。

<=

低于等于 - 再次回到x是不是低于等于y。

(a <= b) 返回 True。

 

导入模块:

实践结果:

已履新字符串 :  Hello Runoob!

 

Python转义字符

在急需在字符中选择特殊字符时,python用反斜杠()转义字符。如下表:

转义字符

描述

(在行尾时)

续行符

\

反斜杠符号

'

单引号

"

双引号

a

响铃

b

退格(Backspace)

e

转义

\000

n

换行

v

纵向制表符

t

横向制表符

r

回车

f

换页

oyy

八进制数,yy代表的字符,例如:o12代表换行

xyy

十六进制数,yy代表的字符,例如:x0a代表换行

other

其它的字符以普通格式输出

 

Python字符串运算符

下表实例变量a值为字符串 "Hello",b变量值为 "Python":

操作符

描述

实例

字符串连接

a b 输出结果: HelloPython

*

重复输出字符串

a*2 输出结果:HelloHello

[]

通过索引获取字符串中字符

a[1] 输出结果 e

[ : ]

截取字符串中的一部分

a[1:4] 输出结果 ell

in

成员运算符 - 如果字符串中包含给定的字符返回 True

H in a 输出结果 1

not in

成员运算符 - 如果字符串中不包含给定的字符返回 True

M not in a 输出结果 1

r/R

原始字符串 - 原始字符串:所有的字符串都是直接按照字面的意思来使用,没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"(可以大小写)以外,与普通字符串有着几乎完全相同的语法。

print r'n' prints n 和 

print R'n' prints n

%

格式字符串

请看下一节内容。

 

a = "Hello" b = "Python" print("a b 输出结果:", a b)
print("a * 2 输出结果:", a * 2)
print("a[1] 输出结果:", a[1])
print("a[1:4] 输出结果:", a[1:4])
if ("H" in a):
    print("H 在变量 a 中")
else:
    print("H 不在变量 a 中")

if ("M" not in a):
    print("M 不在变量 a 中")
else:
    print("M 在变量 a 中")

print(r'n')
print(R'n')

实践结果:

a b 输出结果: HelloPython

a * 2 输出结果: HelloHello

a[1] 输出结果: e

a[1:4] 输出结果: ell

H 在变量 a 中

M 不在变量 a 中

n

n

 

Python字符串格式化

Python 扶助格式化字符串的输出 。就算那样也许会用到非常复杂的表明式,但最基本的用法是将贰个值插入到三个有字符串格式符 %s 的字符串中。

在 Python 中,字符串格式化使用与 C 中 sprintf 函数一样的语法。

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

实践结果:

我叫 小明 今年 10 岁!

 

python字符串格式化符号:

    符   号

描述

      %c

 格式化字符及其ASCII码

      %s

 格式化字符串

      %d

 格式化整数

      %u

 格式化无符号整型

      %o

 格式化无符号八进制数

      %x

 格式化无符号十六进制数

      %X

 格式化无符号十六进制数(大写)

      %f

 格式化浮点数字,可指定小数点后的精度

      %e

 用科学计数法格式化浮点数

      %E

 作用同%e,用科学计数法格式化浮点数

      %g

 %f和%e的简写

      %G

 %f 和 %E 的简写

      %p

 用十六进制数格式化变量的地址

 

格式化操作符支持指令:

符号

功能

*

定义宽度或者小数点精度

-

用做左对齐

在正数前面显示加号( )

<sp>

在正数前面显示空格

#

在八进制数前面显示零('0'),在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')

0

显示的数字前面填充'0'而不是默认的空格

%

'%%'输出一个单一的'%'

(var)

映射变量(字典参数)

m.n.

m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

 

Python三引号

python三引号允许一个字符串跨多行,字符串中能够分包换行符、制表符以及另外特殊字符。实比方下

para_str = """那是三个多行字符串的实例
多行字符串可以使用制表符
TAB (
t )。
也能够使用换行符 [
n ]。
"""
print (para_str)

进行结果:

那是三个多行字符串的实例

多行字符串可以使用制表符

TAB (  )。

也得以使用换行符 [

 ]。

 

三引号让程序猿从引号和奇特字符串的泥潭之中解脱出来,萧规曹随保持一小块字符串的格式是所谓的WYSIWYG(所见即所得)格式的。

几个一流的用例是,当您须要一块HTML也许SQL时,那时用字符串组合,特殊字符串转义将会分外的累赘。

 

Unicode 字符串

在Python第22中学,普通字符串是以8位ASCII码进行仓库储存的,而Unicode字符串则存款和储蓄为14个人unicode字符串,那样能够代表更加的多的字符集。使用的语法是在字符串后边加上前缀 u。

在Python3中,全体的字符串都以Unicode字符串。

 

Python 的字符串内建函数

Python 的字符串常用内建函数如下:

序号

方法及描述

1

capitalize()
将字符串的第一个字符转换为大写

2

center(width, fillchar)


返回一个指定的宽度 width 居中的字符串,fillchar 为填充的字符,默认为空格。

3

count(str, beg= 0,end=len(string))


返回 str 在 string 里面出现的次数,如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

4

bytes.decode(encoding="utf-8", errors="strict")


Python3 中没有 decode 方法,但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象,这个 bytes 对象可以由 str.encode() 来编码返回。

5

encode(encoding='UTF-8',errors='strict')


以 encoding 指定的编码格式编码字符串,如果出错默认报一个ValueError 的异常,除非 errors 指定的是'ignore'或者'replace'

6

endswith(suffix, beg=0, end=len(string))
检查字符串是否以 obj 结束,如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束,如果是,返回 True,否则返回 False.

7

expandtabs(tabsize=8)


把字符串 string 中的 tab 符号转为空格,tab 符号默认的空格数是 8 。

8

find(str, beg=0 end=len(string))


检测 str 是否包含在字符串中,如果指定范围 beg 和 end ,则检查是否包含在指定范围内,如果包含返回开始的索引值,否则返回-1

9

index(str, beg=0, end=len(string))


跟find()方法一样,只不过如果str不在字符串中会报一个异常.

10

isalnum()


如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False

11

isalpha()


如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False

12

isdigit()


如果字符串只包含数字则返回 True 否则返回 False..

13

islower()


如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True,否则返回 False

14

isnumeric()


如果字符串中只包含数字字符,则返回 True,否则返回 False

15

isspace()


如果字符串中只包含空白,则返回 True,否则返回 False.

16

istitle()


如果字符串是标题化的(见 title())则返回 True,否则返回 False

17

isupper()


如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True,否则返回 False

18

join(seq)


以指定字符串作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

19

len(string)


返回字符串长度

20

ljust(width[, fillchar])


返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串,fillchar 默认为空格。

21

lower()


转换字符串中所有大写字符为小写.

22

lstrip()


截掉字符串左边的空格或指定字符。

23

maketrans()


创建字符映射的转换表,对于接受两个参数的最简单的调用方式,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标。

24

max(str)


返回字符串 str 中最大的字母。

25

min(str)


返回字符串 str 中最小的字母。

26

replace(old, new [, max])


把 将字符串中的 str1 替换成 str2,如果 max 指定,则替换不超过 max 次。

27

rfind(str, beg=0,end=len(string))


类似于 find()函数,不过是从右边开始查找.

28

rindex( str, beg=0, end=len(string))


类似于 index(),不过是从右边开始.

29

rjust(width,[, fillchar])


返回一个原字符串右对齐,并使用fillchar(默认空格)填充至长度 width 的新字符串

30

rstrip()


删除字符串字符串末尾的空格.

31

split(str="", num=string.count(str))


num=string.count(str)) 以 str 为分隔符截取字符串,如果 num 有指定值,则仅截取 num 个子字符串

32

splitlines([keepends])


按照行('r', 'rn', n')分隔,返回一个包含各行作为元素的列表,如果参数 keepends 为 False,不包含换行符,如果为 True,则保留换行符。

33

startswith(str, beg=0,end=len(string))


检查字符串是否是以 obj 开头,是则返回 True,否则返回 False。如果beg 和 end 指定值,则在指定范围内检查。

34

strip([chars])


在字符串上执行 lstrip()和 rstrip()

35

swapcase()


将字符串中大写转换为小写,小写转换为大写

36

title()


返回"标题化"的字符串,就是说所有单词都是以大写开始,其余字母均为小写(见 istitle())

37

translate(table, deletechars="")


根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中

38

upper()


转换字符串中的小写字母为大写

39

zfill (width)


返回长度为 width 的字符串,原字符串右对齐,前面填充0

40

isdecimal()


检查字符串是否只包含十进制字符,如果是返回 true,否则返回 false。

 

字符串截取字符补充:

# 0、a,b为数字参数。从字符串指针为a的地方初叶截取字符,到b的前贰个职位(因为不带有b)

var1 = "hello world";

print(var1[a: b]);

 

# 1、如若a,b均不填写,私下认可取全方位字符。即,上边那三个打字与印刷结果是一模一样的

print(var1[: ]);  # hello world

print(var1);      # hello world

 

# 2、假设a填写,b不填写(或填写的值大于指针下标),暗中认可从a早先截取,至字符串最终一个职分

print(var1[3: ]); # lo world

 

# 3、如若a不填写, b填写,默许从0义务上马截取,至b的前贰个职分

print(var1[: 8]); # hello wo

 

# 4、假如a为负数,私下认可从尾部某一职责,开首向后截取

print(var1[-2: ]); # ld

 

# 5、假诺a>=b, 暗中认可输出为空。

print(var1[3: 3]);

print(var1[3: 2]);

 

python字符串格式化符号 %f 可钦点小数点后的精度。

num =18.72554
print("the price  is  %.2f" %num)

奉行结果:

the price  is  18.73

 

运用格式化符号举办进制转换

>>> num=10

>>> print('十六进制:%#x' % num)    #使用%x将十进制num格式化为十六进制

十六进制:0xa

>>> print('二进制:', bin(num))      #运用bin将十进制num格式化为二进制

二进制: 0b1010

>>> print('八进制:%#o' % num)      #选取%o将十进制num格式化为八进制

八进制:0o12

位置运用格式化符号实行进制调换中,多投入了二个#号,指标是在调换结果底部彰显当前进制类型,如无需,可将#号去除,如下

>>> print('八进制:%o' % num)

八进制:12

>>> print('十六进制:%x' % num)

十六进制:a

 

字符串截取字符继续补充:

[::2] 表示的是恒久,步长为2。第三个冒号两边的数字是指截取字符串的限定,第贰个冒号前边是指截取的增进率。

>>> L=['a','b','c','d','e','f','g']

>>> print(L[::2])

['a', 'c', 'e', 'g']

 

字符串别的总结:

字符串的拍卖:

概念字符串a = python,则可开始展览如下操作

字符串全体字符大写:a.upper()

字符串小写:a.lower()

字符串首字符大写,别的字符小写:a.capitalize()

去掉字符串两边的空白符(富含n,t,r,’ ’)或去掉字符串中钦定字符:

如a.strip(‘py’)   输出’thon’   

删去侧边的空白符:a.lstrip()

剔除右侧的空白符:a.rstrip()

判定字符串是不是是数字类型,是回来True,不是回来False  a.isdigit()

研究字符串中字符的开场地方a.find()  如a.find(‘y’)   再次回到结果为1,如找不到重临-1

字符串替换a.replace()  a.replace(‘python’,’Java’)   结果为'java'

拆分字符串,通过点名分隔符对字符串举办切开,并赶回分割后的字符串列表(list)的函数:a.split()  具体如下:

a.split(str="",num=string.count(str))[n]

参数表明:
str :表示为分隔符,默以为空格,不过不可能为空('')。若字符串中平素不分隔符,则把任何字符串作为列表的三个要素输出至列表中。
num:表示分割次数。假使存在参数num,则仅相隔成 num 1 个子字符串,而且每一个子字符串能够赋值给新的变量.

[n]:   表示选取第n个分片

专注:当使用空格作为分隔符时,对于中等为空的项会自动忽略

示例:a = “www.hao123.com.cn”

print(a.split())   结果为['www.hao123.com.cn']

print(a.split(‘.’))  结果为['www', 'hao123', 'com', 'cn']

细分叁遍:print(a.split(‘.’))或print(a.split(‘.’),0) 结果为:['www', 'hao123', 'com', 'cn']

细分三回:print(a.split(‘.’),1) 结果为:['www', 'hao123.com.cn']

分割一次并取列表中系列为1的值:print(a.split(‘.’),1)[1] 结果:'hao123.com.cn'

分割最大次数:print(a.split(‘.’),-1)   结果为:['www', 'hao123', 'com', 'cn']

分割最大次数后赋值:a1,a2,a3,a4 = a.split(‘.’,-1)   则a1 = ‘www’  类推。

prompt = "If you tell us who you are, we can personalize the messages you see."

prompt = "nWhat is your first name? "

sorted()  暗中同意大小写排序   sorted(favorite_languages)

set()   例: set(favorite_languages.values()) 同一名称归类

for name, language in favorite_languages.items(): 将字典中的键命名叫name,将字典中的值命名字为language

import random   secret = random.randint(a,b)  导入生成随机数的模块,然后生a,b之间的数字 (包蕴ab)

.extend()   可同非凡候将八个成分扩张到列表中

.insert()   member.insert(1,’成分’),在那之中插入第一名地点为0,第二名地方为1,类推

.remove()  从列表中剔除一个成分,无需知道成分在列表中地方,必须须求通晓成分名称。

.count()  显示有些成分在列表中冒出的次数  示例:member.count(‘李阳’)

.index() 索引函数,返还某成分在列表中的地点

.reverse()  将列表顺序反转  如:member.reverse()

.sort()   将列表成分按从小到吴国序排列 如:member.sort()

.sort()   member.sort(reverse=True)   将列表成分按从大到小顺序排列

.sort()   sorted()  .reverse()  排序函数

 

使用模块还能制止函数名和变量名冲突。同样名字的函数和变量完全能够分别设有不相同的模块中,由此,大家和还好编排模块时,不必考虑名字会与别的模块争辩。不过也要小心,尽量不要与内置函数名字争执。点这里查看Python的保有内置函数。

Exception getopt.GetoptError

在一贯不找到参数列表,或选用的内需的参数为空时会触发该极度。

不行的参数是贰个字符串,表示错误的因由。属性 msg 和 opt 为有关选项的错误消息。

mycompany
├─ __init__.py
├─ abc.py
└─ xyz.py

Community 是免费的,功用也要命强大,它能帮您搜索您发觉不了的语法错误(很要紧)

from Package import specific_submodule

 

"""

Python3 函数

函数是公司好的,可重复使用的,用来达成单一,或相关联成效的代码段。

函数能巩固使用的模块性,和代码的再次利用率。你曾经知道Python提供了广大内建函数,例如print()。但你也能够本人创立函数,那被叫功能户自定义函数。

 

概念七个函数

您可以定义叁个由本人想要成效的函数,以下是差不离的平整:

函数代码块以 def 关键词初步,后接函数标记符名称和圆括号 ()。

别的传入参数和自变量必须放在圆括号中间,圆括号之间可以用来定义参数。

函数的首先行语句能够选用性地动用文档字符串—用于贮存函数表达。

函数内容以冒号早先,而且缩进。

return [表达式] 甘休函数,接纳性地赶回多少个值给调用方。不带表达式的return相当于重回 None。

 

语法

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

def 函数名(参数列表):

    函数体

私下认可情形下,参数值和参数名称是按函数注明中定义的的逐一匹配起来的。

实例

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

def hello() :
   print("Hello World!")

hello()

实行结果:

Hello World!

更复杂点的行使,函数中带上参数变量:

def area(width, height):
    return width * height

def print_welcome(name):
    print("Welcome", name)

print_welcome("Runoob")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))

奉行结果:

Welcome Runoob

width = 4  height = 5  area = 20

 

函数调用

概念叁个函数:给了函数三个称号,内定了函数里包含的参数,和代码块结构。

其一函数的中央结构变成之后,你能够透过另七个函数调用施行,也足以一向从 Python 命令提示符实践。

一般来讲实例调用了 printme() 函数:

# 定义函数
**
def printme(str):
    "打字与印刷任何传入的字符串"     print(str);     
return;
# 调用函数 printme(
"小编要调用用户自定义函数!")
printme(
"再一次调用同一函数"**)

试行结果:

自身要调用用户自定义函数!

双重调用同一函数

 

在 python 中,类型属于对象,变量是绝非项目标

可更动(mutable)与不足改换(immutable)对象

在 python 中,strings, tuples, 和 numbers 是不行更动的靶子,而 list,dict 等则是可以修改的对象。

不足变类型:变量赋值 a=5 后再赋值 a=10,这里其实是新兴成三个 int 值对象 10,再让 a 指向它,而 5 被撤消,不是改动a的值,也便是新生成了a。

可变类型:变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第多个成分值改变,本人la未有动,只是其里面包车型大巴一部分值被改换了。

 

python 函数的参数字传送递:

不行变类型:类似 c 的值传递,如 整数、字符串、元组。如fun(a),传递的只是a的值,未有影响a对象自己。譬如在 fun(a)内部修改 a 的值,只是修改另一个复制的对象,不会影响 a 本身。

可变类型:类似 c 的引用传递,如 列表,字典。如 fun(la),则是将 la 真正的传过去,修改后fun外部的la也会受影响

python 中一切都以对象,严刻意义大家不可能说值传递还是引用传递,大家应该说传不可变对象和传可变对象。

 

python 传不可变对象实例

def ChangeInt( a ):
    a = 10

b = 2
ChangeInt(b)
print( b ) # 结果是 2

实例中有 int 对象 2,指向它的变量是 b,在传递给 ChangeInt 函数时,按传值的办法复制了变量 b,a 和 b 都指向了同一个 Int 对象,在 a=10 时,则新生成三个 int 值对象 10,并让 a 指向它。

 

传可变对象实例

可变对象在函数里修改了参数,那么在调用这么些函数的函数里,原始的参数也被改换了。比方:

# 可写函数表明
**
def changeme(mylist):
    "修改传入的列表"     mylist.append([1, 2, 3, 4]);
    print(
"函数内取值: ", mylist)     return
# 调用changeme函数 mylist = [10, 20, 30];
changeme(mylist);
print(
"函数外取值: "**, mylist)

实行结果:

函数内取值:  [10, 20, 30, [1, 2, 3, 4]]

函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

 

参数

以下是调用函数时可采纳的标准参数类型:

须求参数

珍视字参数

暗许参数

不定长参数

 

须要参数

需求参数须以科学的相继传入函数。调用时的数量必须和注明时的一律。

调用printme()函数,你不能够不传入二个参数,不然会产出语法错误。

 

器重字参数

关键字参数和函数调用关系密不可分,函数调用使用主要字参数来规定传入的参数值。

应用首要字参数允许函数调用时参数的次第与评释时不一样样,因为 Python 解释器能够用参数名相称参数值。

以下实例中示范了函数参数的行使无需动用钦点顺序:

# 可写函数表明
**
def printinfo(name, age):
    "打印任何传入的字符串"     print(
"名字: ", name);
    print(
"年龄: ", age);     return;
# 调用printinfo函数 printinfo(age=50, name=
"runoob")
printinfo(50,
'kobe')
printinfo(
'allen'**,50)

施行结果:

名字:  runoob

年龄:  50

名字:  50

年龄:  kobe

名字:  allen

年龄:  50

 

默许参数

调用函数时,若无传递参数,则会利用暗许参数。以下实例中假若未有传来 age 参数,则选用暗中同意值。暗中认可参数必须放在最前面,不然会报错

##可写函数说明
**
def printinfo( name, age = 35 ):
   "打字与印刷任何传入的字符串"    print (
"名字: ", name);
   print (
"年龄: ", age);    return;
 #调用printinfo函数 printinfo( age=50, name=
"runoob" );
print (
"------------------------")
printinfo( name=
"runoob"** );

实施结果:

名字:  runoob

年龄:  50


名字:  runoob

年龄:  35

 

不定长参数

您可能须求三个函数能管理比那时声称时愈来愈多的参数。这一个参数叫做不定长参数,和上述2种参数不一致,声明时不会取名。基本语法如下:

def functionname([formal_args,] *var_args_tuple ):
   "函数_文书档案字符串"    function_suite
   return [expression]

加了星号(*)的变量名会存放全体未命名的变量参数。如若在函数调用时从没点名参数,它正是叁个空元组。咱们也能够不向函数字传送递未命名的变量。如下实例:

# 可写函数表明
**
def printinfo(arg1, *vartuple):
    "打字与印刷任何传入的参数"     print(
"输出: ")
    print(arg1)     
for var in vartuple:
        print(var)     
return*; # 调用printinfo 函数
*printinfo(10);
printinfo(70, 60, 50);

进行理并了结果:

输出:

10

输出:

70

60

50

 

无名氏函数

python 使用 lambda 来创建无名氏函数。

所谓佚名,意即不再利用 def 语句那样规范的情势定义一个函数。

lambda 只是三个表明式,函数体比 def 轻松非常多。

lambda的重心是二个表明式,实际不是多少个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

lambda 函数具备自身的命名空间,且不可能访谈本人参数列表之外或全局命名空间里的参数。

尽管如此lambda函数看起来只可以写一行,却不等同C或C 的内联函数,后面一个的目标是调用小函数时不占用栈内存进而扩大运营功效。

 

语法

lambda 函数的语法只含有一个言辞,如下:

lambda [arg1 [,arg2,.....argn]]:expression

 

如下实例:

# 可写函数表明 sum = lambda arg1, arg2: arg1 arg2;
# 调用sum函数 print("相加后的值为 : ", sum(10, 20))
print("相加后的值为 : ", sum(20, 20))

实行结果:

相加后的值为 :  30

相加后的值为 :  40

 

return语句

return [表达式] 语句用于退出函数,采取性地向调用方再次来到八个表明式。不带参数值的return语句重临None。以前的事例都并未有亲自过问怎么回到数值,以下实例演示了 return 语句的用法:

# 可写函数表明
**
def sum( arg1, arg2 ):
   # 再次回到2个参数的和."    total = arg1 arg2
   print (
"函数内 : ", total)    return total;
# 调用sum函数 total = sum( 10, 20 );
print (
"函数外 : "**, total)

奉行结果:

函数内 :  30

函数外 :  30

 

变量成效域

Python 中,程序的变量并不是在哪个地方都得以访谈的,访问权限调节于那一个变量是在何地赋值的。

变量的作用域决定了在哪一部分主次能够访谈哪个特定的变量名称。Python的功能域一共有4种,分别是:

L (Local) 局地功用域

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

G (Global) 全局成效域

B (Built-in) 内建作用域

以 L –> E –> G –>B 的准则查找,即:在部分找不到,便会去一些外的一些找(比如闭包),再找不到就能够去全局找,再者去内建中找。

x = int(2.9)  # 内建成效域 g_count = 0  # 全局效率域
**
def* outer():
    o_count = 1  
# 闭包函数外的函数中

    *def inner():
        i_count = 2  # 局地成效域

Python 中独有模块(module),类(class)以及函数(def、lambda)才会引进新的效能域,别的的代码块(如 if/elif/else/、try/except、for/while等)是不会引入新的作用域的,也正是说那这一个语句内定义的变量,外部也能够访问。

借使将 变量msg 定义在函数中,则它便是一些变量,外部无法访谈:

>>> def test():

...     msg_inner = 'I am from Runoob'

...

>>> msg_inner

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

NameError: name 'msg_inner' is not defined

从报错的新闻上看,表达了 msg_inner 未定义,不也许采用,因为它是部分变量,唯有在函数内能够行使。

全局变量和部分变量

概念在函数内部的变量具备四个局地功用域,定义在函数外的具有全局功效域。

一部分变量只好在其被声称的函数内部访问,而全局变量能够在全体程序范围内访谈。调用函数时,所有在函数内申明的变量名称都将被投入到功效域中。如下实例:

 

total = 0; # 那是贰个全局变量

# 可写函数表明

def sum( arg1, arg2 ):

    #回来2个参数的和."

    total = arg1 arg2; # total在此处是一对变量.

    print ("函数内是有个别变量 : ", total)

    return total;

 

#调用sum函数

sum( 10, 20 );

print ("函数外是全局变量 : ", total)

以上实例输出结果:

函数内是有的变量 :  30

函数外是全局变量 :  0

 

global 和 nonlocal关键字

当当中成效域想修改外界功用域的变量时,将要用到global和nonlocal关键字了。

以下实例修改全局变量 num:

 

num = 1

def fun1():

    global num  # 要求利用 global 关键字证明

    print(num)

    num = 123

    print(num)

fun1()

以上实例输出结果:

1

123

 

要是要修改嵌套成效域(enclosing 效用域,外层非全局功用域)中的变量则需求nonlocal 关键字了,如下实例:

 

def outer():

    num = 10

    def inner():

        nonlocal num   # nonlocal关键字注解

        num = 100

        print(num)

    inner()

    print(num)

outer()

上述实例输出结果:

100

100

 

别的有一种特殊处境,借使上面这段代码被周转:

 

a = 10

def test():

    a = a 1

    print(a)

test()

上述程序执行,报错音讯如下:

Traceback (most recent call last):

  File "test.py", line 7, in <module>

    test()

  File "test.py", line 5, in test

    a = a 1

UnboundLocalError: local variable 'a' referenced before assignment

错误音讯为一些成效域引用错误,因为 test 函数中的 a 使用的是局地,未定义,不可能修改。

 

def(**kwargs) 把N个关键字参数转化为字典:

>>> def func(country,province,**kwargs):

...       print(country,province,kwargs)

...

>>> func("China","Sichuan",city = "Chengdu", section = "JingJiang")

China Sichuan {'city': 'Chengdu', 'section': 'JingJiang'}

 

lambda 佚名函数也是足以应用"关键字参数"举行参数字传送递

>>> g= lambda x,y : x**2 y**2

>>> g(2,3)

13

>>> g(y=3,x=2)

13

同样地,lambda 佚名函数也能够设定暗许值

>>> g= lambda x=0,y=0 : x**2 y**2

>>> g(2,3)

13

>>> g(2)

4

>>> g(y=3)

9

注意:如若只准备给个中一部分参数设定暗中认可值,那么相应将其放在靠后的岗位(和定义函数时同样,制止歧义),不然会报错。

 

全局变量和一些变量和 js 有点貌似

>>> b=1

>>> def ss(a):

...     c=a b

...     print(c)

...

>>> print(b)

1

>>> ss(10)

11

说明:

b 在 ss(a) 函数外定义,在函数内部能够直接采纳,和本教程中的最终二个事例有差别。

在 js 中也是能够间接利用函数外界的变量,只可是外界变量供给采纳var 注明。

 

 

看似的,能够有数不尽目录,组成多级档期的顺序的包结构。比如如下的目录结构:

保留字即器重字,我们无法把它们作为别的标志符或变量名称。Python 的规范库提供了一个 keyword 模块,能够输出当前版本的持有入眼字:

1.注释

缩进:

文件中有普通话,不管是还是不是为注释,python2实施报错。 

或在先后第一行打上# -*- coding: UTF-8 -*-

你恐怕还想到,假若不一样的人编写的模块名同样如何做?为了制止模块名争辨,Python又引入了按目录来公司模块的法子,称为包(Package)。

Number(数字):

Python3 支持 int、float、bool(True,False,其中True等于1,False等于0)、complex(复数)。

在Python 3里,唯有一种整数类型 int,表示为长整型,不再将整数区分为整型与长整型。

像大大多言语同样,数值类型的赋值和计量都以很直观的。

整型(Int) - 日常被称之为是整型或整数,是正或负整数,不带小数点。Python3 整型是平昔不界定大小的,能够视作 Long 类型使用,所以 Python3 未有 Python2 的 Long 类型。

浮点型(float) - 浮点型由整数局地与小数部分构成,浮点型也足以行使科学计数法表示(2.5e2 = 2.5 x 102 = 250)

复数( (complex)) - 复数由实数部分和虚数部分组成,能够用a bj,也许complex(a,b)表示, 复数的实部a和虚部b都是浮点型。

 

整数(int), 如 1

浮点数(float) 如 1.23、3E-2

复数(complex) 如 1 2j、 1.1 2.2j

布尔类型:True, False

 

放到的 type() 函数能够用来查询变量所指的对象类型。

>>> a, b, c, d = 20, 5.5, True, 4 3j

>>> print(type(a), type(b), type(c), type(d))

<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

 

除此以外还足以用 isinstance 来判别:

>>>a = 111

>>> isinstance(a, int)   #isinstance(x,y)剖断x,y是或不是同样,是重返True,否再次回到Fales

True

isinstance 和 type 的分别在于:

class  A:

pass

class  B(A):

pass

isinstance(A(),A)   # returns True

type(A()) == A     # returns True

isinstance(B(),A)   # returns True

type(B()) == A     # returns False

由结果可知type()不会感觉子类是一种父类类型。

isinstance()会感到子类是一种父类类型。

 

 

Python3 中,把 True 和 False 定义成首要字了,但它们的值依然 1 和 0,它们得以和数字相加。

 

当你钦定叁个值时,Number 对象就能被成立:

var1 = 1

var2 = 10

您也得以采取del语句删除一些对象引用。

del语句的语法是:

del var1[,var2[,var3[....,varN]]]]

你能够经过应用del语句删除单个或多个目的。举例:

del var

del var_a, var_b

 

注意:

八个变量能够通过赋值指向区别类型的靶子。

在混合总结时(变量中既有整型又有浮点型),Python会把整型转换来为浮点数。

 

局地数值类型的实例:

int

float

complex

10

0.0

3.14j

100

15.20

45.j

-786

-21.9

9.322e-36j

080

32.3 e18

.876j

-0490

-90.

-.6545 0J

-0x260

-32.54e100

3e 26J

0x69

70.2-E12

4.53e-7j

Python支持复数,复数由实数部分和虚数部分组成,能够用a bj,大概complex(a,b)表示, 复数的实部a和虚部b都以浮点型。

a = 4.52e-7j

print(a.real)    #打印a的实数部分,输出0.0

print(a.imag)   #打字与印刷a的虚数部分,输出4.52e-07

 

Python字符串:

Python中的字符串用单引号(')或双引号(")括起来,同期利用反斜杠()转义特殊字符。

字符串的截取(切成丝)的语法格式如下:变量[头下标:尾下标]

索引值以 0 为始发值,-1 为从最终的开头地点。

加号 ( ) 是字符串的连接符, 星号 (*) 表示复制当前字符串,紧跟的数字为复制的次数。实比如下:

str = 'Runoob' print(str)  # 输出字符串 print(str[0:-1])  # 输出第多少个到尾数第贰个的持有字符 print(str[0])  # 输出字符串第一个字符 print(str[2:5])  # 输出从第多个开首到第八个的字符 print(str[2:])  # 输出从第多个早先的后的具备字符 print(str * 2)  # 输出字符串四遍 print(str "TEST")  # 连接字符串

实施结果:

Runoob

Runoo

R

noo

noob

RunoobRunoob

RunoobTEST

 

Python 使用反斜杠()转义特殊字符,借使你不想让反斜杠爆发转义,能够在字符串前边增加一个r,表示原始字符串:

print('Runoob')

进行结果:

Ru

Oob

 

print(r'Runoob')

实行结果:

Runoob

另外,反斜杠()能够看作续行符,表示下一行是上一行的继续。也得以使用 """...""" 恐怕 '''...''' 跨更加多行。

留意,Python 未有独立的字符类型,四个字符就是长度为1的字符串。

word = 'Python' print(word[0], word[5])

试行结果:

P n

与 C 字符串不一样的是,Python 字符串无法被转移。向叁个目录地点赋值,举个例子word[0] = 'm'会导致错误。

注意:

1、反斜杠能够用来转义,使用r能够让反斜杠不爆发转义。

2、字符串能够用 运算符连接在共同,用*运算符重复。

3、Python中的字符串有两种索引格局,从左往右以0开始,从右往左以-1初步。

4、Python中的字符串不能够改造。

 

字符串或串(String)是由数字、字母、下划线组成的一串字符。

一般记为 :

s="a1a2···an"(n>=0)

它是编制程序语言中表示文本的数据类型。

python的字串列表有2种取值顺序:

从左到右索引暗中认可0初叶的,最大规模是字符串长度少1

从右到左索引暗中认可-1起头的,最大范围是字符串开首

假设你要落到实处从字符串中赢得一段子字符串的话,能够行使变量 [头下标:尾下标],就能够截取相应的字符串,在那之中下标是从 0 初阶算起,能够是正数或负数,下标可认为空表示取到头或尾。

比如:

s = 'ilovepython'

print(s[1:5])      结果是:love。

当使用以冒号分隔的字符串,python重临二个新的指标,结果包罗了以那对偏移标记的连接的始末,左侧的开端是带有了上边界。

地方的结果富含了s[1]的值l,而取到的最大面积不包罗上边界,正是s[5]的值p。

加号( )是字符串连接运算符,星号(*)是再次操作。如下实例:

str = 'Hello World!' print str # 输出完整字符串

print str[0] # 输出字符串中的第二个字符

print str[2:5] # 输出字符串中第多少个至第三个里面包车型客车字符串

print str[2:] # 输出从第三个字符发轫的字符串

print str * 2 # 输出字符串三次

print str "TEST" # 输出连接的字符串

如上实例输出结果:

Hello World!

H

llo

llo World!Hello World!Hello World!Hello World!TEST

 

 

import package

Tuple(元组)

元组(tuple)与列表类似,分歧之处在于元组的成分无法修改。元组写在小括号(())里,成分之间用逗号隔绝。

元组中的成分类型也能够分歧:

tuple = ('abcd', 786, 2.23, 'runoob', 70.2)
tinytuple = (123, 'runoob')
print(tuple)  # 输出完整元组 print(tuple[0])  # 输出元组的率先个要素 print(tuple[1:3])  # 输出从第1个要素起首到第多少个要素 print(tuple[2:])  # 输出从第4个要素开头的享有因素 print(tinytuple * 2)  # 输出四次元组 print(tuple tinytuple)  # 连接元组

推行结果:

('abcd', 786, 2.23, 'runoob', 70.2)

abcd

(786, 2.23)

(2.23, 'runoob', 70.2)

(123, 'runoob', 123, 'runoob')

('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')

 

元组与字符串类似,能够被索引且下标索引从0起首,-1 为从最后开头的地点。也足以张开截取(看下边,这里不再赘言)。

实则,能够把字符串看作一种非常的元组。

修改元组成分的操作是违法的。

尽管如此tuple的成分不可退换,但它能够富含可变的对象,比如list列表。

结构满含 0 个或 1 个要素的元组相比新鲜,所以有一对外加的语法规则:

tup1 = ()    # 空元组 tup2 = (20,) # 二个要素,须求在要素后增多逗号

string、list和tuple都属于sequence(序列)。

注意:

1、与字符串同样,元组的要素不可能改改。

2、元组也得以被索引和切成丝,方法同样。

3、注意社团包括0或1个要素的元组的非正规语法准绳。

4、元组也得以运用 操作符举行拼接。

 

 

3.模块:

List(列表)

List(列表) 是 Python 中选拔最频仍的数据类型。

列表能够做到大多数集合类的数据结构实现。列表七月素的花色能够不一致等,它扶助数字,字符串以至足以包含列表(所谓嵌套)。

列表是写在方括号([])之间、用逗号分隔断的元素列表。

和字符串同样,列表同样能够被索引和截取,列表被截取后回去三个带有所需成分的新列表。

列表截取的语法格式如下:变量[头下标:尾下标]

索引值以 0 为开头值,-1 为从最后的起第二地方。

加号( )是列表连接运算符,星号(*)是再一次操作。如下实例:

list = ['abcd', 786, 2.23, 'runoob', 70.2]
tinylist = [123, 'runoob']
print(list)  # 输出完整列表 print(list[0])  # 输出列表第一个成分 print(list[1:3])  # 从第四个起来出口到第多少个成分 print(list[2:])  # 输出从第4个要素起先的保有因素 print(tinylist * 2)  # 输出一回列表 print(list tinylist)  # 连接列表

实践结果:

['abcd', 786, 2.23, 'runoob', 70.2]

abcd

[786, 2.23]

[2.23, 'runoob', 70.2]

[123, 'runoob', 123, 'runoob']

['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

 

与Python字符串区别等的是,列表中的成分是足以退换的:

a = [1, 2, 3, 4, 5, 6]
a[2:5] = [13,14,15]
print(a)
a[2:5]= []  #删除 print(a)

实践结果:

[1, 2, 13, 14, 15, 6]

[1, 2, 6]

 

List内置了有许多主意,譬喻append()、pop()等等,那在末端会讲到。

注意:

1、List写在方括号之间,元素用逗号隔断。

2、和字符串同样,list能够被索引和切成片。

3、List能够运用 操作符实行拼接。

4、List中的成分是足以更动的。

 

 

2.编码

Python赋值运算符

运算符

描述

实例

=

简单的赋值运算符

c = a b 将 a b 的运算结果赋值为 c

=

加法赋值运算符

c = a 等效于 c = c a

-=

减法赋值运算符

c -= a 等效于 c = c - a

*=

乘法赋值运算符

c *= a 等效于 c = c * a

/=

除法赋值运算符

c /= a 等效于 c = c / a

%=

取模赋值运算符

c %= a 等效于 c = c % a

**=

幂赋值运算符

c **= a 等效于 c = c ** a

//=

取整除赋值运算符

c //= a 等效于 c = c // a

 

注意:和煦创建立模型块时要留意命名,不能够和Python自带的模块名称冲突。比如,系统自带了sys模块,自个儿的模块就不行命名字为sys.py,不然将无法导入系统自带的sys模块。

以下内容为互连网拷贝加上一些友好收拾得来。侵删。

print("hello world") 

https://www.python.org/downloads/windows/   官网

行使模块有怎样好处?

print 暗许输出是换行的,假若要促成不换行必要在变量末尾加上 end="":

print(“Hello World!”)   结果为:Hello World

print(“Hello World!”,end=”I Love You!”)   结果为:Hello World!I Love You!

Python能够同样行呈现多条语句,方法是用;分开比方:

print(“Hello”);print(“world!”)

展现结果为:

Hello

world!

 

help() 函数:

调用 python 的 help() 函数能够打字与印刷输出多个函数的文书档案字符串:

正如实例,查看 max 内置函数的参数列表和规范的文书档案

>>> help(max)

结果如下:

Help on built-in function max in module builtins:

 

max(...)

    max(iterable, *[, default=obj, key=func]) -> value

    max(arg1, arg2, *args, *[, key=func]) -> value

    

    With a single iterable argument, return its biggest item. The

    default keyword-only argument specifies an object to return if

    the provided iterable is empty.

    With two or more arguments, return the largest argument.

 

要是只是想取得文书档案字符串:

>>> print(max.__doc__)    # 注意,doc的光景分别是五个下划线

结果如下:

max(iterable, *[, default=obj, key=func]) -> value

max(arg1, arg2, *args, *[, key=func]) -> value

With a single iterable argument, return its biggest item. Thedefault keyword-only argument specifies an object to return if

the provided iterable is empty.With two or more arguments, return the largest argument.

 

Help()函数别的用法:

查看python所有的modules:help("modules")

单看python全数的modules中含有钦点字符串的modules: help("modules yourstr")

查看python中遍布的topics: help("topics")

查阅python标准库中的module:import os.path help("os.path")

翻看python内置的连串:help("list")

翻开python类型的分子方法:help("str.find") 

查阅python内置函数:help("open")

 

Python 标识符:

在 Python 里,标志符由字母、数字、下划线组成。

在 Python 中,全数标记符能够总结法文、数字以及下划线(_),但不可能以数字开始。

Python 中的标记符是分别轻重缓急写的。

以下划线发轫的标记符是有优秀含义的。以单下划线先导 _foo 的象征不可能一向访谈的‘类’属性,需通过‘类’提供的接口实行访谈,无法用 from xxx import * 而导入;

以双下划线开端的 __foo 代表类的村办成员;

以双下划线起首和最后的 __foo__ 代表 Python 里特殊方式专项使用的标志,如 __init__() 代表类的构造函数

 

五个语句构成代码组:

缩进一样的一组语句构成三个代码块,大家称之代码组。

像if、while、def和class那样的复合语句,首行以重大字开端,以冒号( : )截至,该行之后的一行或多行代码构成代码组。

大家将首行及末端的代码组称为多个子句(clause)。

正如实例:

if expression:

suite

elif expression:

suite

else:

suite

 

等候用户输入input()函数:

实践上边包车型大巴先后在按回车键后就能够等待用户输入:

input(“nn按下enter键后退出:”)

以上代码中 ,"nn"在结果输出前会输出五个新的空行。一旦用户输出实现,程序将退出。

 

同一行显示多条语句:

Python能够在同样行中选取多条语句,语句之间利用分号(;)分割,以下是一个差不离的实例:

import sys; x = 'runoob'; sys.stdout.write(x 'n')

进行以上代码,输入结果为:

Runoob

7

 

注明与引号:

Python中单行注释用#始于,也可用于程序后加注释。例子如下:

# 第2个注释

print (“Hello World”)   # 第一个注释

 

python中单引号和双引号使用完全同样。

三引号同一时候能够作笺注,用三引号括起来的内容不会在程序中推行。

 

 

事比方下:

'''

那是多行注释,使用单引号。

这是多行注释,使用单引号。

那是多行注释,使用单引号。

'''

或:

"""

那是多行注释,使用双引号。

那是多行注释,使用双引号。

那是多行注释,使用双引号。

"""

用多少个单引号和多个双引号括起来的5行在程序中起注释成效,不会在先后中实行。

 

再者:使用三引号('''或""")能够钦点一个多行字符串:

a = """lksjdflkksjlfdjjgljflk
sdfsdjfsdklfjslkk
sdkfjslkadjlkjdlk
"""
b ='''dfslaksdjflkasjdflkad
sdfljasldfkjaslkdf
sdfkladskjflkds
sldfkjal
'''

print(a)

print(b)

结果如下:

lksjdflkksjlfdjjgljflk

sdfsdjfsdklfjslkk

sdkfjslkadjlkjdlk

 

dfslaksdjflkasjdflkad

sdfljasldfkjaslkdf

sdfkladskjflkds

sldfkjal

 

 

 

print 输出:

return 的作用

在三个 generator function 中,若无 return,则私下认可推行至函数完成,尽管在实行进度中 return,则直接抛出 StopIteration 终止迭代。

 

空行与代码缩进不一致,空行并非Python语法的一有的。书写时不插入空行,Python解释器运转也不会出错。然则空行的意义在于分隔两段不一致作用或含义的代码,便于日后代码的掩护或重构。

https://www.bilibili.com/video/av9784617/?from=search&seid=6723760175629363784#page=51                          爬虫教程(大学教授)

设置python正式版本后,展开CMD,输入pip install pygame就可安装pygame

 

Python3 循环语句:

本章节将为大家介绍Python循环语句的选拔。

Python中的循环语句有 for 和 while。

Python循环语句的调节结构图如下所示:

 

 

while 循环

Python中while语句的形似格局:

While 决断规范:

语句

同样须要小心冒号和缩进。另外,在Python中并未有do..while循环。

以下实例使用了 while 来计量 1 到 100 的总额:

n = 100
sum = 0
counter = 1
while counter <= n:
    sum = sum counter
    counter = 1
print("1 到 %d 之和为: %d" % (n, sum))

施行结果为:1 到 100 之和为: 5050

 

最好循环

大家得以经过安装规范表明式永恒不为 false 来完成Infiniti循环,实比方下:

var = 1
while var == 1:  # 表达式永久为 true     num = int(input("输入三个数字  :"))
    print("你输入的数字是: ", num)

print("Good bye!")

上述程序会一贯进行。你能够行使 CT冠道L C 来退出当前的极端循环。

Infiniti循环在服务器上客户端的实时需要特别实用。

 

while 循环利用 else 语句

在 while … else 在尺度语句为 false 时进行 else 的语句块:

count = 0
while count < 5:
   print (count, " 小于 5")
   count = count 1
else:
   print (count, " 大于或等于 5")

实施结果为:

0  小于 5

1  小于 5

2  小于 5

3  小于 5

4  小于 5

5  大于或等于 5

 

轻巧易行语句组

临近if语句的语法,假诺您的while循环体中唯有一条语句,你能够将该语句与while写在同一行中, 如下所示:

flag = 1
while (flag): print('应接访谈新手教程!')

上述的极致循环你能够应用 CT君越L C 来制动踏板循环。

进行以上脚本,输出结果如下:

接待访问新手教程!

招待待上访谈菜鸟教程!

接待访问新手教程!

招待访谈新手教程!

 

for 语句

Python for循环能够遍历任何种类的门类,如一个列表也许贰个字符串。

for循环的形似格式如下:

for <variable> in <sequence>:
    <statements>
else:
    <statements>

实例:

languages = ["C", "C ", "Perl", "Python"]
for x in languages:
    print(x)

推行结果:

C

C

Perl

Python

 

以下 for 实例中央银行使了 break 语句,break 语句用于跳出当前循环体:

sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    if site == "Runoob":
        print("新手教程!")
        break              # break跳出了for循环,间接实践循环之后的print实现循环语句     print("循环数据 " site)
else:
    print("未有循环数据!")
print("完成循环!")

实行结果如下:

巡回数据 Baidu

巡回数据 Google

新手教程!

完了循环!

 

range()函数

设若你供给遍历数字类别,能够选拔内置range()函数。它会生成数列,举个例子:

for i in range(5):
    print(i)

试行结果:

0

1

2

3

4

for i in range(5,9):
    print(i)

推行结果:

5

6

7

8

也得以使range以钦定数字开始并点名不相同的增量(乃至足以是负数,一时这也称之为'步长'):

for i in range(0,10,3):
    print(i,end=",")

实行结果:0,3,6,9,

for i in range(-10,-100,-30):
    print(i,end=",")

实施结果:-10,-40,-70,

 

您可以组成range()和len()函数以遍历贰个行列的目录,如下所示:

a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
for i in range(len(a)):
    print(i,":",a[i])

执行结果:

0 : Google

1 : Baidu

2 : Runoob

3 : Taobao

4 : QQ

 

还足以应用range()函数来成立二个列表:

print(list(range(5)))

进行结果:[0, 1, 2, 3, 4]

 

 

break和continue语句及循环中的else子句:

break 语句能够跳出 for 和 while 的循环体。假如你从 for 或 while 循环中截至,任何对应的循环 else 块将不实行。 实譬喻下:

for letter in 'Runoob':  # 第一个实例
    **
if letter == 'b':         break
    print('当前字母为 :', letter)
var = 10  # 第一个实例
while var > 0:
    print(
'当期变量值为 :', var)
    var = var - 1     
if var == 5:         break
print("Good bye!"**)

实践结果:

当下字母为 : 奥迪Q5

时下字母为 : u

现阶段字母为 : n

近年来字母为 : o

当前字母为 : o

当期变量值为 : 10

当期变量值为 : 9

当期变量值为 : 8

当期变量值为 : 7

当期变量值为 : 6

Good bye!

 

continue语句被用来报告Python跳过当前循环块中的剩余语句,然后继续展开下一轮循环。

for letter in 'Runoob':  # 第贰个实例
    **
if letter == 'o':  # 字母为 o 时跳过输出         continue
    print('当前字母 :', letter)
var = 10  # 第4个实例
while var > 0:
    var = var - 1     
if var == 5:  # 变量为 5 时跳过输出         continue
    print('当前变量值 :', var)
print(
"Good bye!"**)

实施结果:

日前字母 : XC60

当下字母 : u

时下字母 : n

现阶段字母 : b

这段时间变量值 : 9

当前变量值 : 8

当下变量值 : 7

脚下变量值 : 6

此时此刻变量值 : 4

近日变量值 : 3

当前变量值 : 2

近些日子变量值 : 1

脚下变量值 : 0

Good bye!

 

循环语句能够有 else 子句,它在穷尽列表(以for循环)或规范成为 false (以while循环)导致循环终止时被实践,但循环被break终止时不实施。

式例循环执市价况:

i=0
j=0
for n in range(2, 10):
    i =1
    print("第一重循环推行第%d次;"% (i),"n 的数值为:%d" % (n))
    for x in range(2, n):
        j =1
        print("      第二重循环实践第%d次;" % (j),"x 的数值为:%d" % (x))

推行结果:

第一重循环施行第1次; n 的数值为:2

率先重循环施行第2次; n 的数值为:3

      第二重循环推行第1次; x 的数值为:2

先是重循环施行第3次; n 的数值为:4

      第二重循环推行第2次; x 的数值为:2

      第二重循环推行第3次; x 的数值为:3

先是重循环推行第4次; n 的数值为:5

      第二重循环施行第4次; x 的数值为:2

      第二重循环实施第5次; x 的数值为:3

      第二重循环试行第6次; x 的数值为:4

先是重循环实践第5次; n 的数值为:6

      第二重循环施行第7次; x 的数值为:2

      第二重循环施行第8次; x 的数值为:3

      第二重循环实行第9次; x 的数值为:4

      第二重循环实行第14遍; x 的数值为:5

第一重循环试行第6次; n 的数值为:7

      第二重循环试行第13次; x 的数值为:2

      第二重循环实践第14遍; x 的数值为:3

      第二重循环试行第十四次; x 的数值为:4

      第二重循环施行第十四次; x 的数值为:5

      第二重循环实行第十五遍; x 的数值为:6

首先重循环实行第7次; n 的数值为:8

      第二重循环实行第13遍; x 的数值为:2

      第二重循环实践第19回; x 的数值为:3

      第二重循环实行第18遍; x 的数值为:4

      第二重循环实行第19回; x 的数值为:5

      第二重循环实施第二十次; x 的数值为:6

      第二重循环实践第贰10次; x 的数值为:7

率先重循环实施第8次; n 的数值为:9

      第二重循环试行第20回; x 的数值为:2

      第二重循环实施第20次; x 的数值为:3

      第二重循环实践第二十一回; x 的数值为:4

      第二重循环实践第二十回; x 的数值为:5

      第二重循环实施第贰十九遍; x 的数值为:6

      第二重循环施行第三十回; x 的数值为:7

      第二重循环推行第三十五次; x 的数值为:8

 

 

 

 

 

一般来讲实例用于查询质数的轮回例子:

for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(n, '等于', x, '*', n//x)
            break
    else
:
        # 循环中从不找到成分         print(n, ' 是质数')

施行结果:

2  是质数

3  是质数

4 等于 2 * 2

5  是质数

6 等于 2 * 3

7  是质数

8 等于 2 * 4

9 等于 3 * 3

 

pass 语句:

Python pass是空语句,是为着保持程序结构的完整性。

pass 不做任何事情,一般用做占位语句,如下实例

while True:

pass   # 等待键盘中断(Ctrl C)

 

class MyEmptyClass:

pass

 

以下实例在字母为 o 时 实施 pass 语句块:

for letter in 'Runoob':
    if letter == 'o':
        pass         print('执行 pass 块')
    print('当前字母 :', letter)
print("Good bye!")

施行结果:

方今字母 : LAND

当前字母 : u

当下字母 : n

执行 pass 块

时下字母 : o

执行 pass 块

此时此刻字母 : o

近年来字母 : b

Good bye!

 

可以运用内置 enumerate 函数实行遍历:

for index, item in enumerate(sequence):

    process(index, item)

sequence = [12, 34, 34, 23, 45, 76, 89]
for i, j in enumerate(sequence):
    print(i,":",j)

施行结果:

0 : 12

1 : 34

2 : 34

3 : 23

4 : 45

5 : 76

6 : 89

 

使用循环嵌套来贯彻99乘法法规:

#异乡一层循环调整行数
#i是行数
i=1
while i<=9:
     #里面一层循环调控每一行中的列数      j=1
     while j<=i:
          mut =j*i
          print("%d*%d=%d"%(j,i,mut), end="  ")
          j =1
     print("")
     i =1

施行结果:

1*1=1  

1*2=2  2*2=4  

1*3=3  2*3=6  3*3=9  

1*4=4  2*4=8  3*4=12  4*4=16  

1*5=5  2*5=10  3*5=15  4*5=20  5*5=25  

1*6=6  2*6=12  3*6=18  4*6=24  5*6=30  6*6=36  

1*7=7  2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49  

1*8=8  2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64  

1*9=9  2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81  

 

for 循环的嵌套使用实例:

for i in range(1,6):
   for j in range(1, i 1):
      print("*",end='')
   print('r')

试行结果:

 

*

**

***

****

*****

 

 

 

getopt.getopt 方法

getopt.getopt 方法用于分析命令行参数列表,语法格式如下:

getopt.getopt(args,options[,long_options])

艺术参数表达:

  • args: 要分析的命令行参数列表。
  • options: 以字符串的格式定义,options后的冒号(:)表示该接纳必须有增大的参数,不带冒号表示该选项不附加参数。
  • long_options: 以列表的格式定义,long_options 后的等号(=)表示假使设置该选用,必须有增大的参数,不然就不附加参数。
  • 该措施重返值由多少个要素结合: 第三个是 (option, value) 元组的列表。 第三个是参数列表,富含那多少个并未有'-'或'--'的参数。

其它三个艺术是 getopt.gnu_getopt,这里相当少做牵线。

Python学习网址引用

Python3 元组

Python 的元组与列表类似,分裂之处在于元组的成分不能够修改。

元组使用小括号,列表使用方括号。

元组创设很粗大略,只需求在括号中添美成分,并动用逗号隔开分离就能够。

正如实例:

tup1 = ('Google', 'Runoob', 1997, 2000);

tup2 = (1, 2, 3, 4, 5 );

tup3 = "a", "b", "c", "d";

成立空元组

tup1 = ();

元组中只富含一个要素时,必要在要素后边增加逗号,否则括号会被用作运算符使用:

元组中只包含三个因素时,需求在要素前边增加逗号,不然括号会被看成运算符使用:

tup1 = (50)
tup2 =(50,)
print(type(tup1))
print(type(tup2))

实施结果:

<class 'int'>

<class 'tuple'>

 

元组与字符串类似,下标索引从0初阶,能够开始展览截取,组合等。

 

访谈元组

元组能够行使下标索引来访谈元组中的值,如下实例:

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

实践结果:

tup1[0]:  Google

tup2[1:5]:  (2, 3, 4, 5)

 

修改元组

元组中的成分值是不允许修改的,但大家得以对元组进行一而再组合,如下实例:

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 以下修改元组成分操作是不合法的。
# tup1[0] = 100
# 创制一个新的元组
tup3 = tup1 tup2
print (tup3)

进行结果:

(12, 34.56, 'abc', 'xyz')

 

剔除元组

元组中的成分值是不允许删除的,但大家得以应用del语句来删除全体元组,如下实例:

tup = ('Google', 'Runoob', 1997, 2000)
print (tup)
del tup[0]
print ("删除后的元组 tup : ",tup)

实行结果:

('Google', 'Runoob', 1997, 2000)

Traceback (most recent call last):

  File "C:/Users/X230/Desktop/usr/1021.py", line 3, in <module>

    del tup[0]

TypeError: 'tuple' object doesn't support item deletion

 

Process finished with exit code 1

 

元组运算符

与字符串同样,元组之间能够利用 号和 * 号举行演算。那就象征她们得以构成和复制,运算后会生成二个新的元组。

Python 表达式

结果

描述

len((1, 2, 3))

3

计算元素个数

(1, 2, 3) (4, 5, 6)

(1, 2, 3, 4, 5, 6)

连接

('Hi!',) * 4

('Hi!', 'Hi!', 'Hi!', 'Hi!')

复制

3 in (1, 2, 3)

True

元素是否存在

for x in (1, 2, 3): print x,

1 2 3

迭代

 

元组索引,截取

因为元组也是一个体系,所以大家得以访谈元组中的钦点地点的因素,也得以截取索引中的一段成分,如下所示:

元组:

L = ('Google', 'Taobao', 'Runoob')

Python 表达式

结果

描述

L[2]

'Runoob!'

读取第三个元素

L[-2]

'Taobao'

反向读取;读取倒数第二个元素

L[1:]

('Taobao', 'Runoob!')

截取元素,从第二个开始后的所有元素。

 

元组内置函数

Python元组包蕴了以下内置函数

序号

方法及描述

实例

1

len(tuple)
计算元组元素个数。

>>> tuple1 = ('Google', 'Runoob', 'Taobao')

>>> len(tuple1)

3

>>>

2

max(tuple)
返回元组中元素最大值。

>>> tuple2 = ('5', '4', '8')

>>> max(tuple2)

'8'

>>>

3

min(tuple)
返回元组中元素最小值。

>>> tuple2 = ('5', '4', '8')

>>> min(tuple2)

'4'

>>>

4

tuple(seq)
将列表转换为元组。

>>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu']

>>> tuple1=tuple(list1)

>>> tuple1

('Google', 'Taobao', 'Runoob', 'Baidu')

 

 

Python3 变量:

Python 中的变量不需求注脚。每一种变量在应用前都不可能不赋值,变量赋值以往该变量才会被创建。在 Python 中,变量就是变量,它并没有项目,大家所说的"类型"是变量所指的内部存款和储蓄器中目的的类型。等号(=)用来给变量赋值。等号(=)运算符左边是贰个变量名,等号(=)运算符左边是积攒在变量中的值。举例:

counter = 100 # 整型变量

miles = 1000.0 # 浮点型变量

name = "runoob" # 字符串

print (counter)  结果为100

print (miles)   结果为1000.0

print (name)   结果为runoob

 

多少个变量赋值:

Python允许你还要为多少个变量赋值。比方:a = b = c = 1

以上实例,创立三个整型对象,值为1,多个变量被分配到同样的内部存款和储蓄器空间上。

您也足感到多少个对象钦定八个变量。举例:a, b, c = 1, 2, "runoob"

以上实例,三个整型对象 1 和 2 的分配给变量 a 和 b,字符串对象 "runoob" 分配给变量 c。

Python3 基本数据类型

https://www.jetbrains.com/pycharm/download/#section=windows       Pycharm官方网站,当中Professional是收取费用的,作用越来越多

Python算术运算符

运算符

描述

实例

加 - 两个对象相加

a b 输出结果 31

-

减 - 得到负数或是一个数减去另一个数

a - b 输出结果 -11

*

乘 - 两个数相乘或是返回一个被重复若干次的字符串

a * b 输出结果 210

/

除 - x 除以 y

b / a 输出结果 2.1

%

取模 - 返回除法的余数

b % a 输出结果 1

**

幂 - 返回x的y次幂

a**b 为10的21次方

//

取整除 - 返回商的整数部分

9//2 输出结果 4 , 9.0//2.0

输出结果 4.0

 

本文由金沙澳门官网发布于网络编程,转载请注明出处:python基础语法

关键词: 金沙澳门官网

上一篇:集成ueditor工具
下一篇:没有了