来自 奥门威尼斯网址 2019-12-06 23:47 的文章
当前位置: 威尼斯国际官方网站 > 奥门威尼斯网址 > 正文

python基础语法

1.注释

Python笔记,

Python学习网站推荐

安装教程

   官网

程序好习惯编辑器,用这个不如用pycharm社区免费版

针对geany上有汉字报错的情况,请在每次编程时在程序第一行打上#coding=gbk

或在程序第一行打上# -*- coding: UTF-8 -*-

  Pygame  

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

      菜鸟教程

                          爬虫教程(大学教授)

 教程,注意选python3,别选成2了

       Pycharm官网,其中Professional是收费的,功能更多

Community 是免费的,功能也非常强大,它能帮你找出你发现不了的语法错误(很关键)

    学习网站

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

以下内容为网上拷贝加上部分自己整理得来。侵删。

缩进:

Python的核心!Python PEP 8建议每级缩进都使用四个空格,这既可提高可读性,又留下了足够的多级缩进空间。在字处理文档中,大家常常使用制表符而不是空格来缩进。对于文字处理文档来说,这样做的效果很好,但混合使用制表符和空格会让Python解释器感到迷惑。每款文本编辑器都提供了一种设置,可将输入的制表符转换为指定数量的空格。你在编写代码时应该使用制表符键,但一定要对编辑器进行设置,使其在文档中插入空格而不是制表符。在程序中混合使用制表符和空格可能导致极难解决的问题。如果你混合使用了制表符和空格,可将文件中所有的制表符转换为空格,大多数编辑器都提供了这样的功能。(可以不看,缩进就是Tab键)

缩进错误会出现如下报错:

IndentationError: unexpected indent 错误是 python 编译器是在告诉你"Hi,老兄,你的文件里格式不对了,可能是tab和空格没对齐的问题",所有 python 对格式要求非常严格。

如果是 IndentationError: unindent does not match any outer indentation level错误表明,你使用的缩进方式不一致,有的是 tab 键缩进,有的是空格缩进,改为一致即可。

因此,在 Python 的代码块中必须使用相同数目的行首缩进空格数。

建议你在每个缩进层次使用 单个制表符 或 两个空格 或 四个空格 , 切记不能混用。

 

空行:

函数之间或‘类’的方法之间用空行分隔,表示一段新的代码的开始。类和函数入口之间也用一行空行分隔,以突出函数入口的开始。

空行与代码缩进不同,空行并不是Python语法的一部分。书写时不插入空行,Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码,便于日后代码的维护或重构。

记住:空行也是程序代码的一部分。

 

python保留字:

保留字即关键字,我们不能把它们用作任何标识符或变量名称。Python 的标准库提供了一个 keyword 模块,可以输出当前版本的所有关键字:

>>> import keyword

>>> keyword.kwlist

['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

 

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

多行语句:

Python 通常是一行写完一条语句,但如果语句很长,我们可以使用反斜杠()来实现多行语句,例如:total = 'item_one' +

               'item_two' +

                'item_three'

 

在 [], {}, 或 () 中的多行语句,不需要使用反斜杠(),例如:

total =['item_one',  ‘item_two’, ‘item_three’

               'item_four',  'item_five' ]

'''

print 输出:

print("hello world") 

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中单行注释用#开头,也可用于程序后加注释。例子如下:

# 第一个注释

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

 

'''

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

在 python 用 import 或者 from...import... 来导入相应的模块或模块中的功能函数。

"""

将整个模块(somemodule)导入,格式为: import somemodule

将整个模块(somemodule)导入并重新命名:如import pygame as pg

将pygame模块导入并将其重命名为pg

print("hello world") 

从某个模块中导入某个函数,格式为: from somemodule import somefunction

"""

从某个模块中导入多个函数,格式为: from somemodule import firstfunc, secondfunc, thirdfunc

2.编码

将某个模块中的全部函数导入,格式为: from somemodule import *

import sys
print('================Python import mode==========================');
print ('命令行参数为:')
for i in sys.argv:
    print (i)
print ('n python 路径为',sys.path)

python2 = assic =  不支持中文

执行结果:

================Python import mode==========================

命令行参数为:

C:/Users/X230/Desktop/usr/1021.py

 

 python 路径为 ['C:\Users\X230\Desktop\usr', 'C:\Users\X230\Desktop\usr', 'C:\Users\X230\AppData\Local\Programs\Python\Python36\python36.zip', 'C:\Users\X230\AppData\Local\Programs\Python\Python36\DLLs', 'C:\Users\X230\AppData\Local\Programs\Python\Python36\lib', 'C:\Users\X230\AppData\Local\Programs\Python\Python36', 'C:\Users\X230\AppData\Local\Programs\Python\Python36\lib\site-packages']

文件中有中文,不管是否为注释,python2执行报错。 

 

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

导入sys模块的argv,path成员:

from sys import argv, path  # 导入特定的成员 print('================python from import===================================')
print('path:', path)  # 因为已经导入path成员,所以此处引用时不需要加sys.path

执行结果:

python3 = unicode = 默认支持中文

================python from import===================================

3.模块:

path: ['C:\Users\X230\Desktop\usr', 'C:\Users\X230\Desktop\usr', 'C:\Users\X230\AppData\Local\Programs\Python\Python36\python36.zip', 'C:\Users\X230\AppData\Local\Programs\Python\Python36\DLLs', 'C:\Users\X230\AppData\Local\Programs\Python\Python36\lib', 'C:\Users\X230\AppData\Local\Programs\Python\Python36', 'C:\Users\X230\AppData\Local\Programs\Python\Python36\lib\site-packages']

在计算机程序的开发过程中,随着程序代码越写越多,在一个文件里代码就会越来越长,越来越不容易维护。

 

为了编写可维护的代码,我们把很多函数分组,分别放到不同的文件里,这样,每个文件包含的代码就相对较少,很多编程语言都采用这种组织代码的方式。在Python中,一个.py文件就称之为一个模块(Module)。

Python3命令行参数:

Python 提供了 getopt 模块来获取命令行参数。

Python 中也可以所用 sys 的 sys.argv 来获取命令行参数:

  • sys.argv 是命令行参数列表。
  • len(sys.argv) 是命令行参数个数。

import sys
print ('参数个数为:', len(sys.argv), '个参数。')
print ('参数列表:', str(sys.argv))

执行结果:

参数个数为: 1 个参数。

参数列表: ['C:/Users/X230/Desktop/usr/1021.py']

使用模块有什么好处?

getopt模块

getopt模块是专门处理命令行参数的模块,用于获取命令行选项和参数,也就是sys.argv。命令行选项使得程序的参数更加灵活。支持短选项模式(-)和长选项模式(--)。

该模块提供了两个方法及一个异常处理来解析命令行参数。

最大的好处是大大提高了代码的可维护性。其次,编写代码不必从零开始。当一个模块编写完毕,就可以被其他地方引用。我们在编写程序的时候,也经常引用其他模块,包括Python内置的模块和来自第三方的模块。

getopt.getopt 方法

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

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

方法参数说明:

  • args: 要解析的命令行参数列表。
  • options: 以字符串的格式定义,options后的冒号(:)表示该选项必须有附加的参数,不带冒号表示该选项不附加参数。
  • long_options: 以列表的格式定义,long_options 后的等号(=)表示如果设置该选项,必须有附加的参数,否则就不附加参数。
  • 该方法返回值由两个元素组成: 第一个是 (option, value) 元组的列表。 第二个是参数列表,包含那些没有'-'或'--'的参数。

另外一个方法是 getopt.gnu_getopt,这里不多做介绍。

使用模块还可以避免函数名和变量名冲突。相同名字的函数和变量完全可以分别存在不同的模块中,因此,我们自己在编写模块时,不必考虑名字会与其他模块冲突。但是也要注意,尽量不要与内置函数名字冲突。点这里查看Python的所有内置函数。

Exception getopt.GetoptError

在没有找到参数列表,或选项的需要的参数为空时会触发该异常。

异常的参数是一个字符串,表示错误的原因。属性 msg 和 opt 为相关选项的错误信息。

你也许还想到,如果不同的人编写的模块名相同怎么办?为了避免模块名冲突,Python又引入了按目录来组织模块的方法,称为包(Package)。

Python3 基本数据类型

举个例子,一个abc.py的文件就是一个名字叫abc的模块,一个xyz.py的文件就是一个名字叫xyz的模块。

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。

现在,假设我们的abcxyz这两个模块名字与其他模块冲突了,于是我们可以通过包来组织模块,避免冲突。方法是选择一个顶层包名,比如mycompany,按照如下目录存放:

 

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

Python3 中的六个标准的数据类型:

Number(数字)

String(字符串)

List(列表)

Tuple(元组)

Sets(集合)

Dictionary(字典)

 

引入了包以后,只要顶层的包名不与别人冲突,那所有模块都不会与别人冲突。现在,abc.py模块的名字就变成了mycompany.abc,类似的,xyz.py的模块名变成了mycompany.xyz

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

 

 

请注意,每一个包目录下面都会有一个__init__.py的文件,这个文件是必须存在的,否则,Python就把这个目录当成普通目录,而不是一个包。__init__.py可以是空文件,也可以有Python代码,因为__init__.py本身就是一个模块,而它的模块名就是mycompany

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:])  # 输出从第三个元素开始的所有元素 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中的元素是可以改变的。

 

 

类似的,可以有多级目录,组成多级层次的包结构。比如如下的目录结构:

Tuple(元组)

元组(tuple)与列表类似,不同之处在于元组的元素不能修改。元组写在小括号(())里,元素之间用逗号隔开。

元组中的元素类型也可以不相同:

tuple = ('abcd', 786, 2.23, 'runoob', 70.2)
tinytuple = (123, 'runoob')
print(tuple)  # 输出完整元组 print(tuple[0])  # 输出元组的第一个元素 print(tuple[1:3])  # 输出从第二个元素开始到第三个元素 print(tuple[2:])  # 输出从第三个元素开始的所有元素 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、元组也可以使用+操作符进行拼接。

 

 

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

Set(集合)

集合(set)是一个无序不重复元素的序列。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。

student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student)  # 输出集合,重复的元素被自动去掉
# 成员测试
**
if ('Rose' in student):
    print(
'Rose 在集合中') else:
    print(
'Rose 不在集合中')
# set可以进行集合运算 a = set(
'abracadabra')
b = set(
'alacazam'*)
print(a)
print(a - b)  
# a和b的差集
print(a | b)  # a和b的并集
print(a & b)  # a和b的交集
print(a ^ b)  # a和b中不同时存在的元素*

执行结果:

{'Jack', 'Tom', 'Rose', 'Mary', 'Jim'}

Rose 在集合中

{'a', 'r', 'b', 'd', 'c'}

{'r', 'b', 'd'}

{'a', 'm', 'l', 'r', 'b', 'z', 'd', 'c'}

{'a', 'c'}

{'z', 'r', 'b', 'm', 'd', 'l'}

 

 

本文由威尼斯国际官方网站发布于奥门威尼斯网址,转载请注明出处:python基础语法

关键词: