基本数据类型、三元运算、深浅拷贝和函数

Posted on 2016-05-09 09:54 琪齐阅读(350) 评论(0) 收藏举报

基础数据类型补充

set： set集合，是一个无序且不重复的元素集合

1.创建

s = set() 可创建空的集合

或 s ={11,22,33,}

2.转换

   l = []
   l = ()
   l = "123"
   s = set(l)   s = set()

3.去重

示例:`enter code here`
lst = [1,2,3,4,1,2]
print list(set(lst))
运算结果：
[1, 2, 3, 4]

4.基本操作

4.1,difference 找出集合中不存在的，并将其赋值给新变量

se = {11,22,33,44,}
be = {22,33,55,66,}
ret = se.difference(be) #找出se中存在be中不存在的集合，并将其赋值给新变量
print(ret)
运算结果：
{11, 44}


se = {11,22,33,44,}
be = {22,33,55,66,}
ret = be.difference(se) #找住be中存在se中不存在的集合，并将其赋值给新变量
print(ret)
运算结果：
{66, 55}

4.2,difference _update() 找到se中存在，be中不存在的集合，更新自己

se = {11,22,33,44,}
be = {22,33,55,66,}

ret = se.difference_update(be) #找到se中存在，be中不存在的集合，更新自己
print(se)
运算结果：
{11, 44}

4.3, intersection 交集

l1=[11,22,33]
l2=[22,33,44]
ret = list(set(l1).intersection(set(l2))) #交集
print(ret)
输出：
[33, 22]

4.4, issubset 子序列，父序列

se = {11,22,33,44,}
be = {22,33,}
ret = se.issubset(be) #子序列，父序列(谁多谁是父序列，反则子序列)
print(ret)
运算结果：
True

4.5，pop 移除，并把值取出来

se = {11,22,33,44,}
be = {22,33,55,66,}
ret = se.pop()   # 移除，并把值取出来
print(ret)
print(se)
运算结果：
33
{11, 44, 22}

4.6，symmetric_difference 对称交集

se = {11,22,33,44,}
be = {22,33,55,66,}
ret = se.symmetric_difference(be) #对称交集
print()
运算结果：
{66, 11, 44, 55}

4.7，update 更新集合中的元素

se = {11,22,33,44,}
be = {22,33,55,66,}
ret = se.update("hjwj")  #更新集合中的元素
print(se)
运算结果：
{'j', 33, 11, 44, 'h', 22, 'w'}

4.8， union 并集

se = {11,22,33,44,}
be = {22,33,55,66,}
ret = se.union(be)  # 并集
print(ret)
运算结果：
{33, 66, 11, 44, 22, 55}

4.9， discard 移除指定文件，不存在是不报错

se = {22,33,44,}
ret = se.discard(11)#移除指定文件，不存在是不报错

 print(ret) 运算结果： None

4.10 ，remove移除元素，不存在会报错

se = {22,33,44,}
ret = se.remove(11) #移除元素，不存在会报错
print(se)

4.11, clear 清除集合

se = {22,33,44,}
ret = se.clear()  # 清除集合
print(se)
运算结果：
set()

4.12， add 增加

se = {22,33,44,}
ret = se.add(35) # 增加
print(se)
运算结果：
{33, 35, 44, 22}

4.13， issubset 判断交集有是False,没有True

se = {22,33,44,}
be = {22,33,55,66,}
ret = se.issubset(be) #判断交集有是False,没有True
print(ret)
运算结果：
False

三元运算

result = 值1 if 条件 else 值2

如果条件成立，那么将 “值1” 赋值给result变量，否则，将“值2”赋值给result变量

示例：
name = "sb" if  1==1  else "xb"
print(name)

深浅拷贝

1，数字和字符串
字符串和数字的深浅拷贝的内存地址都指向同一个。

2，其他基本数据类型

2.1 赋值
赋值，只是创建一个变量，该变量指向原来内存地址

2.2，浅拷贝
在内存中只额外创建第一层数据（最外层的）

import copy

n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n3 = copy.copy(n1)
print(n3，id(n3)

2.3，深拷贝：
在内存中将拷贝所有层（除掉最低层的元素或字符串）

import copy

n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n4 = copy.deepcopy(n1)
print(n4,id(n4)

函数
定义和使用

格式：
def 函数名(参数):

函数体

返回值

示例：
def xb():  
print("xz"）  #定义函数
    if Tyue:
        return True   #执行函数的返回值 
    else:
        return False   #执行函数的返回值
                  
xb() #执行函数

函数的定义主要有如下要点：

1） def：表示函数的关键字
2）函数名：函数的名称，日后根据函数名调用函数
3）函数体：函数中进行一系列的逻辑计算
4）参数：为函数体提供数据
5）返回值：当函数执行完毕后，可以给调用者返回数据。

1、返回值
作用：函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。

  示例：
def xb():  
print("xz"）  #定义函数
    if Tyue:
        return True   #执行函数的返回值 
    else:
        return False   #执行函数的返回值

2，参数

函数的有三中不同的参数：

普通参数
默认参数
动态参数

# ######### 定义函数 ######### 

# name 叫做函数func的形式参数，简称：形参
def func(name):
    print name

# ######### 执行函数 ######### 
#  'wupeiqi' 叫做函数func的实际参数，简称：实参
func('wupeiqi')

普通参数

def func(name, age = 18):
    
    print "%s:%s" %(name,age)

# 指定参数
func('wupeiqi', 19)
# 使用默认参数
func('alex')

注：默认参数需要放在参数列表最后

默认参数

*args表示任何多个无名参数,它是一个tuple

def func(*args):

    print args


# 执行方式一
func(11,33,4,4454,5)

# 执行方式二
li = [11,2,2,3,3,4,54]
func(*li)

动态参数

**kwargs表示关键字参数,它是一个dict

def func(**kwargs):

    print args


# 执行方式一
func(name＝'wupeiqi',age=18)

# 执行方式二
li = {'name':'wupeiqi', age:18, 'gender':'male'}
func(**li)

动态参数

def func(*args, **kwargs):

    print args
    print kwargs

动态参数

2.1 普通参数

  形式参数
     def xb(p)：
     if p =="15132555555":
         return Tyue
     else:
         return False
         
      
  实际参数
    r1 = xb("15132555555")
    r2 = xb("15132555565")
    if r1:
        print("成功")
    else:
        print("失败")
    if r2:
        print("成功")
    else:
        print("失败")

2.2 动态参数

动态参数一
    def f1(*a):
        a = (123,)
        a = (123,456,)
        print(a,type(a))
        
动态参数二
    def f1(**a):
            a = (123')
            a = (123,456,)
            print(a,type(a))
    f1(k1=123,k2=456)
万能参数
    def f1(p,*a,**aa):
        print(p,type(p))
        print(a,type(a))
        print(aa,type(aa))
    f1(11,22,33, k1=123,k2=456)

3，变量

全局变量(都大写)，局部变量（都小写）

def func1():
        a = 123  #局部变量
        global PA
        PA = "eric"
        print(a)
        
def fun2():
        a = 456  #局部变量
        print(PA)
        print(a)
    func1
    fun2

练习题

1、简述普通参数、指定参数、默认参数、动态参数的区别

　　 普通参数就是用户输入的元素按照顺序一一对应输入

　　指定参数就是用户可以指定某一元素传入某一参数中，可以不按顺序

　　默认参数就是提前给参数指定一个数值，如果用户没有输入数值。那么就默认指定的数值是参数

　　动态参数就是可以接收用户输入的多个元素，元祖，列表通常用*args表示，字典通常用*kwargs

详情请参考：http://www.cnblogs.com/wupeiqi/articles/5453708.html

刷新页面返回顶部

琪齐

导航

公告

基本数据类型、三元运算、深浅拷贝和函数