Python 基本语法
【注意】：默认有其他语言基础
注意事项
注释
单行用 #
多行用 "''"
转义
字符串中引号转义用 \
缩进
不要Tab和空格混着用（Py3是不提倡使用Tab）
变量类型
算术运算符
加 减 乘 除 取模 都一样
** : 幂运算
// : 取整除——返回商的整数部分
赋值
规律一样。
a+=b == a + b
其他算术运算符全部类推
比较运算符
和C++ Java都一样
逻辑运算符
and ： 与逻辑 相当于&&
or : 或逻辑 相当于||
not ： 非逻辑 相当于 ！
成员运算符
in ： 如果在指定序列中找到返回true
not in : 在指定序列中没找到返回true
身份运算符
is : 判断两个标识符是不是引用自一个对象 x is y => 相当于 id(x) == id(y)
is not : 判断两个标识符是不是引用不同个对象 x is y => 相当于 id(x) != id(y)
优先级
* > 正负号 按位取反 > / % // > + -> >> << 左移和右移 > &（按位与）> ^（按位异或） |（或运算）> 比较运算 > 身份运算 > 成员运算 > 逻辑运算
基本语句
判断语句
age = 0;
if age > 18:
print("1")
elif age < 18:
print("2")
else
print("3")循环语句
for letter in py:
....
i = 0
while i < 0:
....
其他语句
break : 跳出整个循环
continue : 只跳这一轮
else : while也支持else
pass ： 空语句，只占位置
字符串
单引号，双引号，三引号
单引号双引号一般情况没区别；
如果字符串里面既有单引号又有双引号，则用三引号括起来
str5="""It's "C",I have "A" and "B"。"""
str5='''It's "C",I have "A" and "B"。'''
【注】用单的还是双的没区别
【注】用三引号换行不用n，直接换就行。
print("""1111
2222
3333
""")
转义字符
| (在行尾时) | 续行符 |
|---|---|
| \ | 反斜杠符号 |
| ' | 单引号 |
| " | 双引号 |
| a | 响铃 |
| b | 退格(Backspace) |
| 000 | 空 |
| n | 换行 |
| v | 纵向制表符 |
| t | 横向制表符 |
| r | 回车 |
| f | 换页 |
| oyy | 八进制数，yy 代表的字符，例如：o12 代表换行，其中 o 是字母，不是数字 0。 |
| xyy | 十六进制数，yy代表的字符，例如：x0a代表换行 |
| other | 其它的字符以普通格式输出 |
原始字符串：
可以在字符串开始的引号之前加上 r，使它成为原始字符串。
“原始字符串”完全忽略所有的转义字符，打印出字符串中所有的倒斜杠。
运算符
| + | 字符串连接 | a + b 输出结果： HelloPython |
|---|---|---|
| * | 重复输出字符串 | a*2 输出结果：HelloHello |
| [] | 通过索引获取字符串中字符 | a[1] 输出结果 e |
| [ : ] | 截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。 | a[1:4] 输出结果 ell |
| in | 成员运算符 - 如果字符串中包含给定的字符返回 True | 'H' in a 输出结果 True |
| not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True | 'M' not in a 输出结果 True |
| r/R | 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 | print( r'\n' ) print( R'\n' ) |
| % | 格式字符串 | 请看下一节内容。 |
输入和输出
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 | 用十六进制数格式化变量的地址 |
格式化操作符辅助指令:
| * | 定义宽度或者小数点精度 |
|---|---|
| - | 用做左对齐 |
| + | 在正数前面显示加号( + ) |
| 在正数前面显示空格 | |
| # | 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X') |
| 0 | 显示的数字前面填充'0'而不是默认的空格 |
| % | '%%'输出一个单一的'%' |
| (var) | 映射变量(字典参数) |
| m.n. | m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) |
input() 函数
input() 函数接受一个标准输入数据，返回为 string 类型
>>>a = input("input:")
input:123 # 输入整数
>>> type(a)
# 字符串
>>> a = input("input:")
input:runoob # 正确，字符串表达式
>>> type(a)
# 字符串 字符串内建函数
| 1 | capitalize() 将字符串的第一个字符转换为大写 |
|---|---|
| 2 | center(width, fillchar) 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。 |
| 3 | count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
| 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+1 个子字符串 |
| 32 | splitlines([keepends]) 按照行('r', 'rn', n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 |
| 33 | startswith(substr, beg=0,end=len(string)) 检查字符串是否是以指定子字符串 substr 开头，是则返回 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。 |
常用内置函数
find
• find 函数用于检测字符串中是否包含子字符串 sub，如果指定 start
（开始）和 end （结束）范围，则检查是否包含在指定范围内。如
果包含子字符串则返回开始的索引值，否则返回-1。
• 语法格式如下：
• str.find(sub[, start[, end]])
• 参数含义如下：
• sub：指定检索的字符串
• start：开始索引，默认为0
• end：结束索引，默认为字符串长度
index
• index 函数检测字符串中是否包含子字符串 sub，如果指定 start
（开始）和 end （结束）范围，则检查是否包含在指定范围内。如
果包含子字符串则返回子字符串开始的索引值，否则抛出异常。
• 语法格式如下：
• str.index(sub[, start[, end]])
• 参数含义如下：
• sub：指定检索的字符串
• start：开始索引，默认为0
• end：结束索引，默认为
count
• count 函数用于统计字符串中 sub 子串出现的次数，可以设定开始
与结束位置来限制字符串的搜索范围。
• 语法格式如下：
• str.count(sub[, start[, end]])
• 参数含义如下：
• sub：搜索的子字符串
• start：字符串开始搜索的位置，默认为第一个字符，该字符索引值为0
• end：字符串结束搜索的位置，默认为字符串的长度
replace
• replace 函数把字符串中的 old （旧字符串）替换成（新字符串），
该函数返回的是字符串中 old （旧字符串）替换成 new (新字符串)
后生成的新字符串。如果指定第3个参数 count ，则替换不超过
count 次。
• 语法格式如下：
• str.replace(old, new[, count]])
• 参数含义如下：
• old：将被替换的子字符串
• new：新字符串，用于替换 old 子字符串
• count：可选参数，替换不超过 count 次
split
• split 函数通过指定分隔符对字符串进行切片，如果参数 maxsplit
有指定值，则仅分隔 maxsplit 个子字符串。该函数返回值是分隔后
的字符串列表。
• 语法格式如下：
• str.split(sep=None, maxsplit=-1)
• 参数含义如下：
• sep：分隔符，默认为所有空字符，包括空格、换行（n）、制表符（t）
• maxsplit：分隔次数
startswith
• startswith 函数用于检查字符串是否是以子字符串开头，如果是，
则返回 True，否则返回 False。若指定了 start 和 end 参数的值，
则会在指定的范围内检查。
• 语法格式如下：
• str.startswith(prefix[, start[, end]])
• 参数含义如下：
• prefix：检测的字符串
• start：可选参数，用于设置字符串检测的起始位置
• end：可选参数，用于设置字符串检测的结束位置
upper
• upper 函数用于将字符串中的小写字母转为大写字母，返回小写字
母转为大写字母后的字符串。
• 语法格式如下：
• str.upper()
lower
• lower 函数用于将字符串中的大写字母转为小写字母，返回大写字
母转为小写字母后的字符串。
• 语法格式如下：
• str.lower()
endswith
• endswith 函数用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回 True，否则返回 False。可选参数start 与 end 为检索字符串的开始与结束位置。
• 语法格式如下：
• str.endswith(suffix[, start[, end]])
• 参数含义如下：
• suffix：检测的字符串
• start：字符串中的开始位置
• end：字符串中的结束位置
lstrip
• lstrip 函数用于删除字符串末尾的空格或指定字符，返回的是一个
新字符串。
• 语法格式如下：
• str.lstrip([chars])
• 参数含义如下：
• chars：指定删除的字符，默认为空格
rstrip
• rstrip 函数用于删除字符串右边的空格或指定字符，返回的是一个
新字符串。
• 语法格式如下：
• str.rstrip([chars])
• 参数含义如下：
• chars：指定删除的字符，默认为空格
strip
• strip 函数用于删除字符串头尾的空格或指定字符，返回的是一个新
字符串。
• 语法格式如下：
• str.strip([chars])
• 参数含义如下：
• chars：删除字符串头尾指定的字符，默认为空格
join
• join 函数用于将序列中的元素以指定的字符连接生成一个新字符串。
• 语法格式如下：
• str.join(sequence)
• 参数含义如下：
• sequence：要连接的元素序列
列表与元组
添加修改删除
修改直接按照数组改；
添加：
在末尾添加：list.append({内容})
在中间插入：list.insert({第几个下标}，{内容})
删除：
del list[{下标}]
pop() : 弹出list末尾的元素
pop({下标}) ： 弹出指定下标位置元素
【注】pop() 是有 返回值的，需要一个变量去接收。
remove({希望删除的值的内容}) : 按值删除
列表的排序
list是列表的名字
永久性排序 : list.sort(cmp=None, key=None, reverse=False)——可以传递参数true可以反向排序
临时排序 ： sorted(list)
eg: print(sorted(list))
反转列表 ： list.reverse()
常用函数
返回列表元素个数 ： len(list)
range({从 i 开始},{到 j 结束}) : 生成 i~ j 的一串数字
list.count(obj) ： 统计某个元素在列表中出现的次数
list.extend(seq) ： 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
列表复制
list = [1,2,3,4,5]list_copy = list[:]
访问（切片）
var1 = "Hello World!!!!"var1[i] # 访问数组下标第i个
var1[1:5] # 访问数组下标第1个到第5个
var1[:4] #只要前4个，可以用来做数组更新
var1[2:] # 从数组下标第2个位置开始。
var1[-3:] # 要倒数3个
元组
概念
元组不能修改，只要将一些值用逗号分隔，就能自动创建一个元组
1,2,3==>(1,2,3)
():空括号表示一个空元组 42,表示只包含一个值的元组，一定要加上逗号
tuple的工作原理与list很像：将一个序列作为参数，并将其转换为元组
tuple([1,2,3])==>(1,2,3) tuple('abc')==>('a','b','c') tuple((1,2,3))==>(1,2,3)
元组的切片是元组
元组可以用作映射中的键、集合的成员，但是列表不行
有些内置函数和方法返回元组，一般情况下而言，使用列表足以满足对序列的需求
元组内置函数
len(tuple) : 计算元组元素个数
max(tuple) : 返回元组中元素最大值
min(tuple) : 返回元组中元素最小值
tuple(seq) : 将列表转为元组
字典
字典的概念
字典是另一种可变容器模型,且可存储任意类型对象
字典的每个键值(key=>value)对用冒号":"分割,每个键值对之间用逗号","分割,整个字典包括在花括号"{}"中,
dict = {key1:value1,key2:value2,......,keyN:valueN}
【注】:
键必须是唯一的,但值则不必
值可以取任何数据类型,但键则必须是不可变的,如: 字符串,数字或元组
创建字典
dict = {'name':'lrving','gender':'boy','age':23,'identity':'student','university':'tsinghua'}
print(dict)
输出结果为:
{'name': 'lrving', 'gender': 'boy', 'age': 23, 'identity': 'student', 'university': 'tsinghua'}访问字典
dict ={'name':'lrving','gender':'boy','age':23,'identity':'student','university':'tsinghua'}
print(dict['name']) #访问字典dict中键name的值
print(dict['age']) #访问字典dict中键age的值
#输出结果为:
lrving
23删除字典元素
删除单一元素
dict = {'name':'lrving','gender':'boy','age':23,'identity':'student','university':'tsinghua'}
del dict['university'] #删除键university
print``(``dict``)
#输出结果为:
{'name': 'lrving', 'gender':'boy', 'age':23,'identity': 'student'}清空字典
dict = {'name':'lrving','gender':'boy','age':23,'identity':'student','university':'tsinghua'}
del dict
print(dict)
#输出结果为:(但这会引发一个异常,因为用执行 ``del` `操作后字典不再存在)
Traceback (most recent call last):
File "/Users/liwenfeng/PycharmProjects/Python/study.py", line 157, in
print(dict['name'])
TypeError: 'type' object is not subscriptable 字典特性
1.在一个字典中不允许同一个键出现两次,创建字典时如果同一个键被赋值两次,则只识别后面的值,示例如下:
dict ={'name':'lrving','gender':'boy','age':23,'identity':'student','age':34,'name':'james'} #键name和age出现两次
print(dict)
#输出结果为:
{'name': 'james', 'gender': 'boy', 'age': 34,'identity': 'student'} #可以看出键name和age只识别了后面的两个值james和342.键必须是不可变的,所以可以用数字,字符串和元组充当,而列表则不可行,如下示例:
dict = {['name']:'lrving','gender':'boy',['age']:23}
print(dict['name'])
#输出结果为:
Traceback (most recent call last):
File "/Users/liwenfeng/PycharmProjects/Python/study.py", line 158, in
dict = {['name']:'lrving','gender':'boy',[``'age']:23}
TypeError: unhashable type: 'list' 字典内置函数
len(dict): 计算字典元素个数,即键的总数
dict` `=` `{``'name'``:``'lrving'``,``'gender'``:``'boy'``,``'age'``:``23``,``'identity'``:``'student'``,``'university'``:``'tsinghua'``}
print``(``len``(``dict``))
输出结果为:
5str(dict): 输出字典,以可打印的字符串表示
dict` `=` `{``'name'``:``'lrving'``,``'gender'``:``'boy'``,``'age'``:``23``,``'identity'``:``'student'``,``'university'``:``'tsinghua'``}
print``(``str``(``dict``))
输出结果为:
{``'name'``: ``'lrving'``, ``'gender'``: ``'boy'``, ``'age'``: ``23``, ``'identity'``: ``'student'``, ``'university'``: ``'tsinghua'``}type(variable): 返回输入的变量类型,如果变量是字典就返回字典类型
dict ={'name':``'lrving'``,``'gender'``:``'boy'``,``'age'``:``23``,``'identity'``:``'student'``,``'university'``:``'tsinghua'``}
print``(``type``(``dict``))
输出结果为:
<``class` `'dict'``>字典内置方法
radiansdict.clear()：删除字典内所有元素
radiansdict.copy()：返回一个字典的浅复制
radiansdict.fromkeys()：创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值
radiansdict.get(key, default=None)：返回指定键的值,如果值不在字典中返回default值
key in dict 如果键在字典dict里返回true,否则返回false
radiansdict.items()：以列表返回可遍历的(键,值)元组数组
radiansdict.keys()：返回一个迭代器,可以使用"list()"来转换为列表
radiansdict.setdefault(key, default=None)：和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default
radiansdict.update(dict2)：把字典dict2的键/值对更新到dict里
radiansdict.values()：返回一个迭代器,可以使用"list()"来转换为列表
pop(key[,default])：删除字典给定键"key"所对应的值,返回值为被删除的值;key值必须给出;否则,返回default值
popitem()：随机返回并删除字典中的最后一对键和值
集合
概念
集合(set)是一个"无序的不重复元素序列"
如果集合中有两个或两个以上相同的元素,则在取值时只会取一个(去重)
可以使用大括号"{ }"或者"set()"函数创建集合,注意: 创建一个空集合必须用"set()"而不是"{ }",因为"{ }"是用来创建一个空字典
创建一个集合
a = {'lakers','james',23,'heat','wade','3','kobe','AD'}
b = set('lrving11curry30klay11')
print(a)
print(b)
#输出结果为:
{'kobe', 'heat','AD', 'wade', '3', 23, 'james', 'lakers'}
{'n', 'g', '1', 'a', 'u', 'k', '0', 'l', 'i', 'v', '3', 'r', 'c', 'y'}集合的运算
a = set('cbdcjdsuac')
b = set('ejciaugejasye')
print(a)
print(b)
print(a - b) #a中包含但b中不包含的元素
print(b - a) #b中包含但a中不包含的元素
print(a | b) #a和b的并集
print(a & b) #a和b的交集
print(a ^ b) #不同时包含a和b的元素
#输出结果为:
{'c', 'u', 'a', 's', 'j', 'b', 'd'}
{'u', 'a', 's', 'y', 'j', 'e', 'i', 'c', 'g'}
{'b', 'd'}
{'i', 'y', 'g', `'e'}
{'i', 'c', 'g', 'u', 'a', 's', 'y', 'j', 'e', 'b', 'd'}
{'u', 'a', 's', 'j', 'c'}
{'b', 'y', 'e', 'i', 'd', 'g'}类似列表推导式，同样集合支持集合推导式(Set comprehension)
a = {x for x in 'abracadabra' if x not in 'abc'}
print(a)
#输出结果为:
{'d', 'r'}集合基本操作
添加
方法一：
a ={'lakers','james',23,'heat','wade','3','kobe','AD'}
a.add('NBA')
print(a)
#输出结果为:
{'heat', 'kobe', 'NBA', 'lakers', 'AD', 'wade', 'james', '3', 23}方法二：可以添加元素,且参数可以是列表,元组,字典等,语法格式如下
a.update(x) #"x"可以有多个,用逗号隔开a = {'lakers','james',23,'heat','wade','3','kobe','AD'}
a.update([1,'lrving','Antetokounmpo']) #在集合中添加一个列表
a.update((2,'six','five')) ``#在集合中添加一个元组
a.update({'name':'Howard'}) #在集合中添加字典时,只会添加字典的键,而不会是键的值
print(a)
#输出结果为:
{1, 'heat', 2, 'name', 'Antetokounmpo', 'five', 'AD', 'wade', 'kobe', 'lrving', 'six', 'lakers', 23, 'james', '3'}删除
方法一：
a.remove(x) #将元素"x"从集合"a"中移除,如果元素不存在,则会发生错误a ={'lakers','james',23,'heat','wade','3','kobe','AD'}
a.remove("heat")
print(a)
#输出结果为:
{'3', 'kobe', 'james', 23, 'lakers', 'wade', 'AD'}方法二：
a.discard(x)a = {'lakers','james',23,'heat','wade','3','kobe','AD'}
a.discard('heat')
a.discard('Cleveland') #当覆盖的元素在集合中不存在时,也不会报错
print``(a)
输出结果为:
{'3', 'james','lakers', 'wade', 23, 'kobe', 'AD'}方法三：
a.pop() #这种方法是随机删除集合中的某一个元素a = {'lakers','james',23,'heat','wade','3','kobe','AD'}
a.pop()
print(a)
#输出结果为: (此结果是连续执行两次的结果)
{'kobe', 'wade', 'AD', 'james', 23, 'heat', 'lakers'} #删除了'3'这个元素
{'heat', 'wade', 'kobe', 'lakers', 'james', 23, '3'} #删除了'AD'这个元素清空集合
语法格式:
a.clear()
a = {'lakers','james',23,'heat','wade','3','kobe','AD'}
a.clear()
print(a)
#输出结果为:
set()判断元素是否在集合中存在
语法格式:
x in a #返回结果为True和Flase
a = {'lakers','james',23,'heat','wade','3','kobe','AD'}
print('cleveland' in a)
print(23 in a)
输出结果为:
False
True集合内置方法
add()：为集合添加元素
clear()：移除集合中的所有元素
copy()：拷贝一个集合
difference()：返回多个集合的差集
difference_update()：移除集合中的元素,该元素在指定的集合也存在
discard()：删除集合中指定的元素
intersection()：返回集合的交集
intersection_update()：返回集合的交集
isdisjoint()：判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False
issubset()：判断指定集合是否为该方法参数集合的子集
issuperset()：判断该方法的参数集合是否为指定集合的子集
pop()：随机移除元素
remove()：移除指定元素
symmetric_difference()；返回两个集合中不重复的元素集合
symmetric_difference_update()：移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中
union()：返回两个集合的并集
update()：给集合添加元素
函数
基本用法
#无参=============
def greet():
print("Hello!")
greet()
#含参=============
def greet(user_name):
print("Hello"+user_name.title()+!)
#默认值============
def greet(user_name = "lzorn"):
#返回值============
def add(a, b):
return a + b
#返回字典===========
def person():
person = {'1':a, '2':b, '3':c}
return person
#可选择最后一个参数====
def person(name, age = ''):
#age 是可以不输入的
#参数是列表==========
def greet(names):
for name in names:
msg = "Hello, " + name.title()
peint(msg)
#禁止修改列表========
#将列表的副本传送即可
def name(list_name[:]):
#传递任意个数的参数=====
def make(*top):
print(top)
make(a)
make(a,b,c)
#其中*top是py创建的新空元组
def make(**top):
# **top是要求py创建新的空字典将函数存入模块中
#a.py
def a1():
print("DD磊")
#b.py
import a #要求py打开a.py文件
a.a1()