【澳门葡京备用网址】Python成员运算符,数据结构

Python成员运算符

Python成员运算符,python运算符

Python成员运算符

此外语言未有,是不是带有运算符,主要选择在字符串大概聚众中

测试实例中带有了壹二种的分子,包蕴字符串,列表或元组。

澳门葡京备用网址 1

#动用场景0一:字符串是或不是含有其它八个字符串?

str01 = “MynameisSandy,IcomefromChina”

if “Sandy”instr01:

print(“包含”)

else:

print(“不包含”)

 

#应用场景02:集合中是不是包罗其余二个因素

name_array = [“Alice”, “Bob”, “Peter”, “Tomas”]

name = input(“请输入1位名:”)

If name inname_array:

print(“输入的姓名%s存在于list中”% name)

else:

print(“输入的姓名%s不存在于list中”% name)

 

#运用场景0三:数字集合

num_array = [10,20,30,40,50,60]

if 23 innum_array:

print(“数字存在于list中”)

else:

print(“数字不设有于list中”)

 

Python 成员运算符
其余语言未有,是不是带有运算符,主要采用在字符串可能聚众中
测试实例中蕴藏了一名目诸多的…

1.注释

队列(如列表和元组)、映射(如字典)以及汇集(set)是3类重要的数据结构(也叫做容器)。

任何语言未有,是或不是包括运算符,首要运用在字符串大概聚众中

单行:# 
多行:三个’单引号’或三个”双引号”


测试实例中隐含了1密密麻麻的积极分子,包涵字符串,列表或元组。

”’

队列(列表、元组和字符串)——列表为可变的(可修改),元组和字符串是不可变的(不可修改)。

澳门葡京备用网址 2

print(“hello world”) 

队列中的每一个成分都有自个儿的号子。Python中有八种内建的队列:列表、元组、字符串、Unicode字符串、buffer对象和xrange对象。

#选用场景01:字符串是还是不是含有别的3个字符串?

”’

1.列表

str01 = “MynameisSandy,IcomefromChina”

(1)创建

if “Sandy”instr01:

“””

list=[ ]

print(“包含”)

print(“hello world”) 

(贰)list函数:通过list函数(其实list是1体系型而不是函数)对字符串创立列表分外实用

else:

“””

list 3=list(“hello”)

print(“不包含”)

2.编码

print list 3

 

python二 = assic =  不支持粤语

输出为:[‘h’, ‘e’, ‘l’, ‘l’, ‘o’]

#选拔场景02:集合中是还是不是包括此外二个因素

文本中有中文,不管是不是为注释,python二实践报错。 

2.元组

name_array = [“Alice”, “Bob”, “Peter”, “Tomas”]

消除:程序首行加 #coding=utf-8 或 #*-* coding:utf-8 *-*

(1)创建

name = input(“请输入一个姓名:”)

python三 = unicode = 私下认可扶助中文

t1=1,2,3

If name inname_array:

3.模块:

t2=”jeffreyzhao”,”cnblogs”

print(“输入的姓名%s存在于list中”% name)

在处理器程序的费用进程中,随着程序代码越写更加多,在2个文本里代码就会愈发长,越来越不易于保险。

t3=(1,2,3,4)

else:

为了编写制定可保证的代码,我们把无数函数分组,分别放到差别的文书里,那样,每一种文件包罗的代码就绝对较少,多数编制程序语言都利用那种组织代码的主意。在Python中,一个.py文件就称为一个模块(Module)。

t4=()  #空元组能够用未有包涵内容的圆括号来代表

print(“输入的姓名%s不设有于list中”% name)

利用模块有哪些好处?

t5=(1,)  #只含贰个值的元组,必须加个逗号(,)

 

最大的补益是大大升高了代码的可维护性。其次,编写代码不必从零伊始。当二个模块编写落成,就足以被另内地点引用。大家在编写程序的时候,也时常引用别的模块,包罗Python内置的模块和来源第二方的模块。

print t1,t2,t3,t4,t5  #逗号分隔一些值,元组自动创造完毕

#动用场景0三:数字集结

利用模块还足避防止函数名和变量名争辨。一样名字的函数和变量完全可以分级设有不一样的模块中,由此,大家团结在编写制定模块时,不必想念名字会与其他模块争执。不过也要小心,尽量不要与内置函数名字冲突。点这里查阅Python的具备内置函数。

输出为:(1, 2, 3) (‘jeffreyzhao’, ‘cnblogs’) (1, 2, 3, 4) () (1,)
#元组抢先55%时候是因此圆括号 
                                                                       
                                   括起来的

num_array = [10,20,30,40,50,60]

您只怕还想到,固然不相同的人编写的模块名一样如何做?为了幸免模块名抵触,Python又引进了按目录来组织模块的章程,称为包(Package)。

(2)tuple 函数

if 23 innum_array:

举个例证,一个abc.py的文书正是1个名字叫abc的模块,一个xyz.py的文件便是三个名字叫xyz的模块。

t1=tuple([1,2,3])  #专注符号

print(“数字存在于list中”)

于今,假设大家的abcxyz那八个模块名字与其余模块龃龉了,于是我们能够透过包来组织模块,防止争论。方法是选项2个顶层包名,举例mycompany,依据如下目录存放:

t2=tuple(“jeff”)
 #当只有()时,括号中只好是3个字符或字符串,且无法为数字;不然就会报错

else:

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

t3=tuple((1,2,3)) #小心符号**

print(“数字不设有于list中”)

引进了包之后,只要顶层的包名不与别人争执,那全部模块都不会与外人争持。现在,abc.py模块的名字就成为了mycompany.abc,类似的,xyz.py的模块名改成了mycompany.xyz

printt1

 

请留意,每叁个包目录下边都会有多少个__init__.py的文件,那么些文件是必须存在的,不然,Python就把这么些目录当成普通目录,而不是一个包。__init__.py能够是空文件,也得以有Python代码,因为__init__.py本身正是一个模块,而它的模块名便是mycompany

printt2

恍如的,能够有壹类别目录,组成多级档次的包结构。举例如下的目录结构:

printt3

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

3.字符串

文件www.py的模块名便是mycompany.web.www,五个公文utils.py的模块名分别是mycompany.utilsmycompany.web.utils

(1)创建

注意:温馨创设模块时要留意命名,不能够和Python自带的模块名称争执。比方,系统自带了sys模块,本身的模块就不足命名称为sys.py,不然将不能够导入系统自带的sys模块。

str1=’Hello world’

导入模块:

print str1  #出口字符串:Hello world

import package

print str1[0] #出口字符串的首先个字符:H

from Package import specific_submodule

for c in str1:

Import 模块名

print c    #将字符串中的全数字符进行单个输出:H  e  l  l  o     w  o  r
 l  d

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

(2)格式化

总结:

模块是一组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
的值近似为 三.14贰。

 

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

六.类型调换

a = int(“100”)  # 调换为数字

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

7.python2与python3

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

python贰 中协助 <> 是不等于的情致,python叁不帮助,应该用 != 表示

8.运算符

1、算述运算符:

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

玖.逻辑运算符

not , and , or

优先级(短路原则):

and:条件壹 and 尺度2,假如基准1为假,那么那么些and前后八个规范构成的表明式的猜测结果就势必为假,就不测量规范2了

  or:条件1 or
标准2,借使前边的率先个规格为真,那么那几个or前后五个标准构成的表明式的推断结果就决然为真,就不判定规范2了

10.流程

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

(一)表明式:由操作数和运算符组成的一句代码或讲话,表明式可以求值,能够放在”
= “的右手,用来给变量赋值。

(二)操作运算符:

<  小于

<=  小于或等于

>  大于

>=  大于或等于

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

!=  不等于

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

(4)变量: 存款和储蓄消息,今后被调用

取名规则:

    • 一.字母数字下划线组成
    • 二.不能以数字起头,不能够含有特殊字符和空格
    • 三.不可能以保留字命名
    • 四.不可能以汉字命名
    • 伍.定义的变量名应该有含义
    • 陆.驼峰式命名、下划线分割单词

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

(if…elif…else)

if 条件(如果): 

elif 条件(或如果):  

else否则:

澳门葡京备用网址 3

注意:

  • 壹、每一个条件前边要接纳冒号 :,表示接下去是满足条件后要实践的语句块。
  • 贰、使用缩进来划分语句块,一样缩进数的讲话在一块构成1个语句块。
  • 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
猜的数字小了…
请输入你猜的数字:捌
猜的数字大了…
请输入你猜的数字:九
猜的数字大了…
请输入你猜的数字:七
恭贺,你猜对了!

 

if 嵌套:在嵌套 if 语句中,能够把 if…elif…else 结构放在其它二个if…elif…else 结构中。

 

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

例:

num=int(input(“输入2个数字:”))
if num%2==0:
    if num%3==0:
        print (“你输入的数字可以整除 二 和 三”)
    else:
        print (“你输入的数字可以整除 二,但不可能整除 三”)
else:
澳门葡京备用网址,    if num%3==0:
        print (“你输入的数字可以整除 三,但不可能整除 二”)
    else:
        print (“你输入的数字无法整除 2 和 三”)

 #
推行结果:

输入四个数字:5
你输入的数字无法整除 贰 和 叁

输入二个数字:六
你输入的数字能够整除 2 和 3

 

(while)

while 决断标准: #(while:当…的时候)

    语句

【澳门葡京备用网址】Python成员运算符,数据结构。一、必要注意冒号缩进。另外,在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 来测算 ① 到 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循环能够遍历任何体系的种类,如贰个列表恐怕2个字符串。

例:

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函数)

1、如若你供给遍历数字体系,能够行使内置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

3、也足以使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

字符串格式化使用字符串格式化操作符即百分号%来落到实处:

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)时不往下实践
        break

print (“See you!”)

# 输出结果:

眼下字符为 : f
此时此刻字符为 : r
眼下字符为 : a
当下字符为 : n
时下字符为 : k
当期变量值为 : 十
当期变量值为 : 玖
当期变量值为 : 8
当期变量值为 : 7
当期变量值为 : 陆
See you!

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

例:

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

var = 10 # 第2个实例
while var > 0:
    var = var -1
    if var == 5: # 变量为 5 时跳过输出,继续往下进行
        continue
    print (‘当前变量值 :’, var)
print (“See you!”)

# 输出结果:

此时此刻字符 : f
近期字符 : r
眼前字符 : a
脚下字符 : n
时下字符 : k
现阶段字符 : m
目前字符 : e
当前变量值 : 9
当下变量值 : 八
时下变量值 : 7
现阶段变量值 : 6
目前变量值 : 四
目前变量值 : 3
脚下变量值 : 二
此时此刻变量值 : 壹
方今变量值 : 0
See you!

3、循环语句能够有 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”代表尾数第1,就那样类推
       切片
           — test_str[strat:end]
           — start:初叶索引(包涵这几个因素)
           — end:甘休索引(不带有那些成分)
           — start < end
       不可变
           — 不能够修改

切片例:

str = “dasfaf”

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

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

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

逆序:

str = “abcdefABCDEF” 

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

str[-1:]  # out:”F” (倒数第叁个)

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

str[-1:0:-1]  # out:”FEDChina Basketball Associationfedcb” (逆序,不含第1个)

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

 

3、字符串连接:

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()  #删去两端空格.

1贰.列表 (类似数组,可变,针对笔者的浮动)

运算符

表达式

结果

描述

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] 
#列表中的数据足以是不一样的数据类型。  能够下标,和切成丝。

增加和删除改查

   
    — 一.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 暗中同意-一 (最终3个)

例:#删

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的列表

 

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

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

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()
函数重临3个已排序的行列,并不修改原值

>>> 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未有动,只是其内部的1部分值被涂改了。

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

 

2、可变参数

例:

def printinfo( *vartuple ):

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

   print (“输出: “)

   for var in vartuple:

      print (var)

   return;

 

printinfo(10,32,22)

 

#无名函数(lambda制造匿名函数)

 

sum = lambda arg1, arg2: arg1 + arg2;

 

print (“相加后的值为 : “, sum( 拾, 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

 

1六.迭代器和生成器

1、字符串,列表和元组对象都可用以创设迭代器。

例:

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
是1个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天性,三个模块被另叁个主次第3遍引进时,其主程序将运维。假若大家想在模块被引进时,模块中的某1程序块不实践,能够用name属性。

例:

#!/usr/bin/python3

# Filename: using_name.py

 

if __name__ == ‘__main__’:

   print(‘程序本身在运转’)

else:

   print(‘我来自另壹模块’)

 

#试行结果:

先后自个儿在运作

 

  • Python 会根据 sys.path 中的目录来寻找这一个包中包括的子目录。
  • 目录唯有包括1个叫做 init.py
    的文本才会被认作是1个包,重借使为着制止有个别滥俗的名字(比方叫做
    string)相当的大心的影响搜索路线中的有效模块。
  • 推荐:from Package import specific_submodule

18.文件

open()方法重回文件,第1个参数为文件张开药格局。暗中认可只读r / 写w,a追加…

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

 

f.write(“人生苦短,小编用python!”)

 

f.close()

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

19.类

类方法

例:

class MyClass:

    i = 12345

   
#类方式必须有1个附加的首先个参数,惯例是self,不牢固;代表的的类的实例而非类

    def f(self):

        return “hello world”

 

x = MyClass()

print(“MyClass 类的属性 i 为:”, x.i)

print(“MyClass 类的方式 f 输出为:”, x.f())

 

#进行结果:

MyClass 类的天性 i 为: 123四伍
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))

 

#另1个类,多种承继此前的备选

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相配整个字符串,直到找到3个才子佳人。

例:

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)

 

#进行理并了结果

电话号码 :  201捌-666-66六 

 

例:

import re

phone = “2018-666-666 # 那是叁个电话号码” 

num = re.sub(r’\D’, “”, phone) # 移除非数字的内容

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

 

#推行结果

电话号码 :  201866666陆

 

最后用一张图来归纳:

澳门葡京备用网址 4

str=’Hello,%s’ % ‘world’

print str1


格式化操作符的右操作数能够是此外东西,如果是元组恐怕映射类型(如字典),那么字符串格式化将会迥然不相同

strs=’Hello’,’world’#元组中字符串格式化

str1=’%s,%s’ %strs

print str1

d={‘h’:’Hello’,’w’:’world’}#字典中字符串格式化

str1=’%(h)s,%(w)s’ %d

print str1


留意:假如急需转移的元组作为转换表明式的一某些存在,那么必须将它用圆括号括起来:

str1=’%s,%s’ % (‘Hello’,’world’) #那里若未有圆括号,则会报错

print str1


str1=’%s%%’ %100 #输出%,用2个%

print str1


对数字实行格式化管理,经常必要调节输出的大幅和精度:

from math import pi

str1=’%.2f’ %pi#精度为2,输出3.14

print str1

str1=’%10f’ %pi#字段宽度为十,输出 
3.1415玖3(后面有一个空格,总院长度为10)

print str1

str1=’%10.2f’ %pi #字段10,精度2

print str1


Python中在string模块还提供其它1种格式化值的章程:模板字符串。它的办事章程接近于广大UNIX
Shell里的变量替换,如下所示:

from string import Template

str1=Template(‘$x,$y!’)  #采纳首要字参数举办格式化

str1=str1.substitute(x=’Hello’,y=’world’)

print str1 #Hello,world!

如果轮换字段是单词的一某些,那么参数名称就无法不用括号括起来,从而正确指明结尾:

from string import Template

str1=Template(‘Hello,w${x}d!’)

str1=str1.substitute(x=’orl’)

print str1  #Hello,world!


from string import Template

str1=Template(‘$x$$’) #内需输出$时,输入1个$(同需输出%措施一致)

str1=str1.substitute(x=’100′)

print str1 #100$


除了首要字参数之外,模板字符串还足以使用字典变量提供键值对开始展览格式化:

from string import Template

d={‘h’:’Hello’,’w’:’world’}

str1=Template(‘$h,$w!’)  #可以运用字典变量提供键值对进展格式化

str1=str1.substitute(d)

print str1 #Hello,world!

4.通用种类操作(方法)

那些操作包罗:索引(indexing)、分片(sliceing)、加(adding)、乘(multiplying)以及检查有些成分是不是属于类别的成员。除外,还有划算种类长度、最大一点都不大成分等内置函数.

(1)索引

索引从0(从左向右)开始,全数类别可因而那种方式进行索引。

str1=’Hello’

nums=[1,2,3,4]

t1=(123,234,345)

print str1[0] #输出为:H

print nums[1] #输出为:2

print t1[2] #输出为:345

目录能够从最后2个义务(从右向左)开头,编号是-1

str1=’Hello’

nums=[1,2,3,4]

t1=(123,234,345)

print str1[-1] #输出为o

print nums[-2] #输出为:3

print t1[-3] #输出为123

(2)分片

分片操效用来做客必将范围内的因素。分片通过冒号相隔的四个索引来落成:

nums=range(10)

print nums #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print nums[1:5] #[1, 2, 3, 4]

print nums[1:] #[1, 2, 3, 4, 5, 6, 7, 8, 9]

print nums[-3:-1] #[7, 8]

print nums[-3:] #[7, 8, 9]

print nums[:] #复制整个系列[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

不同的步长,有分裂的输出:

nums=range(10)

print nums[0:10]#暗中同意步长为一, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print nums[0:10:2]#步长为2,[0, 2, 4, 6, 8]

print nums[0:10:-2]#步长为-2, [ ]

(三)种类相加(只可以是同类型的数据开展相加)

str1=’Hello’

str2=’ world’

print str1+str2 #Hello world

num1=[1,2,3] 

num2=[2,3,4]

print num1+num2 #[1, 2, 3, 2, 3, 4](同样数字依旧会冒出)

print str1+num1 #报错:数据类型错误

(4)乘法 

print [None]*10  #[None, None, None, None, None, None, None, None,
None, None]

str1=’Hello’

print str1*2  #HelloHello

num1=[1,2]

print num1*2  #[1, 2, 1, 2]

print str1*num1  #报错:数据类型错误

(5)成员身份

in运算符会用来检查1个目标是否为有个别连串(或然其余类型)的积极分子(即成分):

str1=’Hello’

print ‘h‘ in str1 #False

print ‘H‘ in str1  #True

(6)长度、最大相当小值

通过内建函数len、max和min能够回去类别中所包涵成分的多寡、最大和纤维成分。

str1=’Hello’

print len(str1) #5

print max(str1) #o

print min(str1) #H

num1=[1,2,1,4,123]

print max(num1) #123

print min(num1) #1

格式化操作符的右操作数能够是其余东西,如若是元组大概映射类型(如字典),那么字符串格式化将会迥然分歧。

留神:假设须要退换的元组作为转变表明式的一片段存在,那么必须将它用圆括号括起来:

str1=’%s%%’ %100#输出%,用2个%

print str1

str1=’%s%%’ %100#输出%,用2个%

print str1

str1=’%s%%’ %100#输出%,用2个%

print str1

str1=’%s%%’ %100#输出%,用2个%

print str1

str1=’%s%%’ %100#输出%,用2个%

print str1

str1=’%s%%’ %100#输出%,用2个%

print str1

二、映射(字典)

照耀中的每一个成分都有八个名字,这么些名字专门的学业的称谓叫键。字典(也叫散列表)是Python中唯1内建的照射类型。

1、键类型

字典的键能够是数字、字符串恐怕是元组,键必须唯1。在Python中,数字、字符串和元组都被规划成不足变类型,而常见的列表以及集聚(set)都以可变的,所以列表和集中不能够同日而语字典的键。键可认为别的不可变类型,那多亏Python中的字典最庞大的地点。

d={}  #概念空字典

d[1]=1 #对空字典中的key=1实行赋值一

print d #打字与印刷字典,输出{1:一}

list1=[“hello,world”] #列表为可变的

set1=set([123]) #会合为可变的

d[list1]=”Hello world.”

d[set1]=123

print d  #当键为可变类型时,报错

二、自动抬高

固然键在字典中并不设有,也足认为它分配3个值,那样字典就会建立新的项。

三、成员身份

表明式item in
d(d为字典)查找的是键(containskey),而不是值(containsvalue)。

字典的操作方法可参见官方文书档案。

三、集合

会集set正是由类别(大概别的可迭代的靶子)营造的。会集的多少个第一特征和措施如下:

一、别本是被忽视的

set1=set([0,1,2,3,0,1,2,3,4,5])

print set1 #群集内设有一样参数时,实行统1,只出现二回:set([0, 1, 2,
3, 4, 5]) 

set2=set([0,1,2,3,4,5])

print set2  #set([0, 1, 2, 3, 4, 5])

二、会集成分的次第是随机的

strs=set([‘jeff’,’wong’,’cnblogs’])

print strs #set([‘wong’, ‘cnblogs’, ‘jeff’])

三、集结常用方法

(1)并集:可用“union”或“|”

set1=set([1,2,3])

set2=set([2,3,4])

set3=set1.union(set2)

set4=set1|set2

print set3 #set([1, 2, 3, 4])

print set4 #set([1, 2, 3, 4])

(2)交集:用“&”

set1=set([1,2,3])

set2=set([2,3,4])

set3=set1&set2

print set3 #set([2, 3])


python set() 集合操作符号、数学符号

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website