python第三章

一、三目运算

也叫三元运算,例如result=x if x<y else y

二、集合(set)

集合(set):把不同的元素组成一起形成集合,是python基本的数据类型。

集合元素(set elements):组成集合的成员

1 >>> li=[‘a‘,‘b‘,‘c‘,‘a‘]
2 >>> se =set(li)
3 >>> se
4 set([‘a‘, ‘c‘, ‘b‘])

集合对象是一组无序排列的可哈希的值:集合成员可以做字典的键

>>> li=[[‘a‘,‘b‘,‘c‘],[‘a‘,‘c‘]]
>>> se = set(li)

Traceback (most recent call last):
  File "<pyshell#29>", line 1, in <module>
    se = set(li)
TypeError: list objects are unhashable

集合分类:可变集合、不可变集合

可变集合(set):可添加和删除元素,非可哈希的,不能用作字典的键,也不能做其他集合的元素

不可变集合(frozenset):与上面恰恰相反

集合操作符与关系符号:(忘完了!)

1、创建集合

由于集合没有自己的语法格式,只能通过集合的工厂方法set()和frozenset()创建

>>> s = set(‘beginman‘)
>>> s
set([‘a‘, ‘b‘, ‘e‘, ‘g‘, ‘i‘, ‘m‘, ‘n‘])
>>> t = frozenset(‘pythonman‘)
>>> t
frozenset([‘a‘, ‘h‘, ‘m‘, ‘o‘, ‘n‘, ‘p‘, ‘t‘, ‘y‘])
>>> type(s),type(t)
(<type ‘set‘>, <type ‘frozenset‘>)
>>> len(s),len(t)
(7, 8)
>>> s==t
False
>>> s=t
>>> s==t
True
>>> 

2、访问集合

由于集合本身是无序的,所以不能为集合创建索引或切片操作,只能循环遍历或使用in、not in来访问或判断集合元素。

>>> ‘a‘ in s
True
>>> ‘z‘ in s
False
>>> for i in s:
    print i

a
h
m
o
n
p
t
y
>>> 

3、更新集合

可使用以下内建方法来更新:

s.add()
s.update()
s.remove()

注意只有可变集合才能更新:

>>> s.add(0)

Traceback (most recent call last):
  File "<pyshell#46>", line 1, in <module>
    s.add(0)
AttributeError: ‘frozenset‘ object has no attribute ‘add‘
>>> type(s)
<type ‘frozenset‘>
>>> se = set(s)
>>> se
set([‘a‘, ‘h‘, ‘m‘, ‘o‘, ‘n‘, ‘p‘, ‘t‘, ‘y‘])
>>> type(se)
<type ‘set‘>
>>> se.add(0)
>>> se
set([‘a‘, 0, ‘h‘, ‘m‘, ‘o‘, ‘n‘, ‘p‘, ‘t‘, ‘y‘])
>>> se.update(‘MM‘)
>>> se
set([‘a‘, 0, ‘h‘, ‘m‘, ‘o‘, ‘n‘, ‘p‘, ‘M‘, ‘t‘, ‘y‘])
>>> se.update(‘Django‘)
>>> se
set([‘a‘, 0, ‘D‘, ‘g‘, ‘h‘, ‘j‘, ‘m‘, ‘o‘, ‘n‘, ‘p‘, ‘M‘, ‘t‘, ‘y‘])
>>> se.remove(‘D‘)
>>> se
set([‘a‘, 0, ‘g‘, ‘h‘, ‘j‘, ‘m‘, ‘o‘, ‘n‘, ‘p‘, ‘M‘, ‘t‘, ‘y‘])
>>> 

del:删除集合本身

集合类型操作符

1、in ,not in
2、集合等价与不等价(==, !=)
3、子集、超集(见上表)

>>> set(‘shop‘)<set(‘cheeshop‘)
True
>>> set(‘bookshop‘)>=set(‘shop‘)
True

4、联合(|)

联合(union)操作与集合的OR操作其实等价的,联合符号有个等价的方法,union()。

>>> s1=set(‘begin‘)
>>> s2=set(‘man‘)
>>> s3=s1|s2
>>> s3
set([‘a‘, ‘b‘, ‘e‘, ‘g‘, ‘i‘, ‘m‘, ‘n‘])
>>> s1.union(s2)
set([‘a‘, ‘b‘, ‘e‘, ‘g‘, ‘i‘, ‘m‘, ‘n‘])

但+ 运算则不适合:

>>> s3New = s1+s2

Traceback (most recent call last):
  File "<pyshell#68>", line 1, in <module>
    s3New = s1+s2
TypeError: unsupported operand type(s) for +: ‘set‘ and ‘set‘

5、交集(&)

与集合AND等价,交集符号的等价方法是intersection()

>>> s1&s2
set([‘n‘])
>>> s1.intersection(s2)
set([‘n‘])

6、查补(-)
等价方法是difference()

>>> s1-s2
set([‘i‘, ‘b‘, ‘e‘, ‘g‘])
>>> s1.difference(s2)
set([‘i‘, ‘b‘, ‘e‘, ‘g‘])

7、对称差分(^)

对称差分是集合的XOR(‘异或’),取得的元素属于s1,s2但不同时属于s1和s2.其等价方法symmetric_difference()

>>> s1^s2
set([‘a‘, ‘b‘, ‘e‘, ‘g‘, ‘i‘, ‘m‘])
>>> s1.symmetric_difference(s2)
set([‘a‘, ‘b‘, ‘e‘, ‘g‘, ‘i‘, ‘m‘])

注意:集合之间and,or

>>> s1 and s2
set([‘a‘, ‘m‘, ‘n‘])   #取 s2
>>> s1 or s2
set([‘i‘, ‘b‘, ‘e‘, ‘g‘, ‘n‘]) #取 s1
>>> 

集合、列表、元组、字符串之间转换

>>> list(s1)
[‘i‘, ‘b‘, ‘e‘, ‘g‘, ‘n‘]
>>> str(s1)
"set([‘i‘, ‘b‘, ‘e‘, ‘g‘, ‘n‘])"
>>> tuple(s1)
(‘i‘, ‘b‘, ‘e‘, ‘g‘, ‘n‘)

应用:

‘‘‘最简单的去重方式‘‘‘
lis = [1,2,3,4,1,2,3,4]
print list(set(lis))    #[1, 2, 3, 4]

六、关于集合的内建函数、内建方法

1、len():返回集合元素个数

2、set()、frozenset()工厂函数

3、所有集合方法:

4、仅适合可变集合

三、函数

函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。

函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户自定义函数。


可以定义一个由自己想要功能的函数,以下是简单的规则:

  • 函数代码块以 def 关键词开头,后接函数标识符名称和圆括号()
  • 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
  • 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
  • 函数内容以冒号起始,并且缩进。
  • return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

语法

def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]

默认情况下,参数值和参数名称是按函数声明中定义的的顺序匹配起来的。

实例

以下为一个简单的Python函数,它将一个字符串作为传入参数,再打印到标准显示设备上。

def printme( str ):
   "打印传入的字符串到标准显示设备上"
   print str
   return

函数调用

定义一个函数只给了函数一个名称,指定了函数里包含的参数,和代码块结构。

这个函数的基本结构完成以后,你可以通过另一个函数调用执行,也可以直接从Python提示符执行。

如下实例调用了printme()函数:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 定义函数
def printme( str ):
   "打印任何传入的字符串"
   print str;
   return;

# 调用函数
printme("我要调用用户自定义函数!");
printme("再次调用同一函数");

以上实例输出结果:

我要调用用户自定义函数!
再次调用同一函数

按值传递参数和按引用传递参数

所有参数(自变量)在Python里都是按引用传递。如果你在函数里修改了参数,那么在调用这个函数的函数里,原始的参数也被改变了。例如:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 可写函数说明
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()函数,你必须传入一个参数,不然会出现语法错误:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print str;
   return;

#调用printme函数
printme();

以上实例输出结果:

Traceback (most recent call last):
  File "test.py", line 11, in <module>
    printme();
TypeError: printme() takes exactly 1 argument (0 given)

关键字参数

关键字参数和函数调用关系紧密,函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值。

以下实例在函数 printme() 调用时使用参数名:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print str;
   return;

#调用printme函数
printme( str = "My string");

以上实例输出结果:

My string

下例能将关键字参数顺序不重要展示得更清楚:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print "Name: ", name;
   print "Age ", age;
   return;

#调用printinfo函数
printinfo( age=50, name="miki" );

以上实例输出结果:

Name:  miki
Age  50

缺省参数

调用函数时,缺省参数的值如果没有传入,则被认为是默认值。下例会打印默认的age,如果age没有被传入:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print "Name: ", name;
   print "Age ", age;
   return;

#调用printinfo函数
printinfo( age=50, name="miki" );
printinfo( name="miki" );

以上实例输出结果:

Name:  miki
Age  50
Name:  miki
Age  35

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,和上述2种参数不同,声明时不会命名。基本语法如下:

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

加了星号(*)的变量名会存放所有未命名的变量参数。选择不多传参数也可。如下实例:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 可写函数说明
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 来创建匿名函数。

  • lambda只是一个表达式,函数体比def简单很多。
  • lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
  • lambda函数拥有自己的命名空间,且不能访问自有参数列表之外或全局命名空间里的参数。
  • 虽然lambda函数看起来只能写一行,却不等同于C或C++的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法

lambda函数的语法只包含一个语句,如下:

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

如下实例:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;

# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )
print "相加后的值为 : ", sum( 20, 20 )

以上实例输出结果:

相加后的值为 :  30
相加后的值为 :  40

return语句

return语句[表达式]退出函数,选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值,下例便告诉你怎么做:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 可写函数说明
def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print "函数内 : ", total
   return total;

# 调用sum函数
total = sum( 10, 20 );
print "函数外 : ", total 

以上实例输出结果:

函数内 :  30
函数外 :  30

变量作用域

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下:

  • 全局变量
  • 局部变量

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问。调用函数时,所有在函数内声明的变量名称都将被加入到作用域中。如下实例:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

total = 0; # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
   #返回2个参数的和."
   total = arg1 + arg2; # total在这里是局部变量.
   print "函数内是局部变量 : ", total
   return total;

#调用sum函数
sum( 10, 20 );
print "函数外是全局变量 : ", total 

以上实例输出结果:

函数内是局部变量 :  30
函数外是全局变量 :  0
时间: 2024-10-10 11:09:43

python第三章的相关文章

python第三章数据类型

第三章 数据类型 3.1 整型(int) 3.1.1 整型的长度 py2中有:int有取值范围,对于32位系统而言:-2^31~2^31-1 ? 对于64位系统而言:-2^63~2^63-1 ? 超出范围后,py2自动转换成long(长整型)数据. py3中有:int (int/long)只有int数据. 3.1.2 整除 py2和py3中整除是不一样. py2:整除只保留整数,小数位会舍去.若要保留小数.则在文件头加 from __future__ import division py3整除保

python 第三章 元祖,字典,集合,while循环

元祖 Python的元组与列表类似,不同之处在于元组的元素不能修改. 元组使用小括号,列表使用方括号. 元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可. 1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 tup = (1,2,3,4,"hello","word") 5 print(type(tup)) 创建空元组 1 tup = () 元组中只包含一个元素时,需要在元素后面添加逗号 1 tup =

Python黑帽编程3.0 第三章 网络接口层攻击基础知识

3.0 第三章 网络接口层攻击基础知识 首先还是要提醒各位同学,在学习本章之前,请认真的学习TCP/IP体系结构的相关知识,本系列教程在这方面只会浅尝辄止. 本节简单概述下OSI七层模型和TCP/IP四层模型之间的对应关系,最后是本章教程需要的几个核心Python模块. 3.0.1 TCP/IP分层模型 国际标准化组织(ISO)在1978年提出了"开放系统互联参考模型",即著名的OSI/RM模型(Open System Interconnection/Reference Model).

算法导论 第三章 and 第四章 python

第三章 渐进的基本O().... 常用函数 % 和  // 转换 斯特林近似公式 斐波那契数 第四章 分治策略:分解(递归)--解决(递归触底)--合并 求解递归式的3种方法: 1:代入法(替代法):猜测一个(靠经验)--数学归纳法 ·2:递归树法:画树p31[第3版中文]p51->递归式--证明 3:主方法: 快速,有些地方不能涉及,递归式不易写出 4.1最大数组问题 分治法: 1.A[low ,mid]  2.A[mid+1, high] 3.包含mid中间(想左和右分别遍历组合找出最大)

Head First Python 第二章 函数模块&amp;第三章 文件与异常&amp;第四章 持久存储&amp;第五章 处理数据

第三章 1.共享模块 模块和发布工具箱全世界共享模块 编写函数,以.py为文件后缀名,第三方库都在PyPI *注释代码:三引号(单双都可以) 发布过程P40 使用发布工具,函数模块变成了一个“发布”,可以使用import导入其他程序 2.如果函数模块功能不满意 添加参数以供api选择比添加函数工作量小! 首先考虑BIF内置函数 ----------------------------------------------------------- 第四章 1.文件 open()语句,readlin

Python编程入门-第三章 编写程序 -学习笔记

第三章 编写程序 1.编辑源程序.运行程序 可通过IDLE中File>New File新建一个文本以编辑源程序,编辑完成可通过Run>Run Module(或者F5快捷键)来运行程序.Python源文件都以.py格式存储. 2.从命令行运行程序 除了上述利用IDLE的集成功能运行程序的方式外,当然也可以通过命令行运行程序,命令格式为:python ‘源文件名称.py’. 3.编译源代码 当运行py格式文件时,Python会自动创建相应的.pyc文件,该文件包含编译后的代码即目标代码,目标代码基

Python编程快速上手-让繁琐工作自动化 第三章 函数习题及其答案

第三章 函数习题及其答案 1.为什么在程序中加入函数会有好处? 答:函数减少了重复的代码.这让程序更短,更容易阅读,更容易修改. 2.函数中的代码何时执行: 在函数被定义时,还是在函数被调用时? 答:函数中的代码在函数被调用时执行,而不是在函数定义时. 3.什么语句创建一个函数? 答:def语句定义了(创建了)一个函数. 4.一个函数和一次函数调用有什么区别? 答:函数包含def语句和在def子句中的代码.函数调用让程序执行转到函数内,函数调用求值为该函数的返回值. 5.Python程序中有多少

一个新手的Python自学之旅 #MacBook #《“笨办法”学Python》#第三章:言归正传讲Python:Mac系统的终端Terminal命令行快速入门

第三章:言归正传讲Python:Mac系统的终端Terminal命令行快速入门 以后我都会将<“笨办法”学Python>简称为“这本书” 本人用了近5年的MacBook,但在此之前,从未使用过电脑自带的“终端Terminal”(图标:).在非程序员的世界里,建立和删除文件夹或文件,都是:鼠标右键点新建/删除,这是UI带来的便利.但是,却不知道如何利用命令行实现这些操作. 首先,要掌握几个我们平时常用,但在代码界有另外名称的名词:目录.路径.打印. --目录:我们认为它是这样的:标题:第一章:第

Python读书笔记-第三章,四章

第三章 1. 字符串格式化 >>>format="hello %s  %s world" >>>values=('world','hot') >>>print format % values  #也可以接收单个字符串也 也可以用%f %d这类的类似与c的printf 匹配多个参数的时候应该用圆括号 >>>'%s plus %s equals %s'  %(1,1,2) >>>'%010.2f' %