python基础知识及应用(二)输入输出|递归|深浅拷贝|全局变量|复数

最新推荐文章于 2022-12-18 17:33:50 发布

祥瑞Coding

最新推荐文章于 2022-12-18 17:33:50 发布

阅读量501

点赞数 1

分类专栏： python 编程与算法

本文链接：https://blog.csdn.net/weixin_36474809/article/details/90758145

版权

python 同时被 2 个专栏收录

37 篇文章 7 订阅

订阅专栏

编程与算法

26 篇文章 0 订阅

订阅专栏

一、python输入输出

关于python的输入输出函数：

#输入一组数据并输出
str = raw_input()
print
str

#输入多组数据并输出
import sys

for line in sys.stdin:
    for value in line.split():
        print(value)

二、迭代

迭代如果不够熟练，每次都要临时推导的话，考场上耗费时间。但是在理解迭代原理之后，编程较为简单。
但是迭代需要调用函数栈，较为耗费内存，容易造成堆栈溢出等问题，在编程时尽量不要用。

https://www.jianshu.com/p/965d12083d7f

一个青蛙可以一次跳一个台阶，也可以跳两个，问青蛙跳上n级台阶有多重跳法。

2.1 输入与输出

输出无所谓，需要用标准的print

输入用：

n=int(input())

2.2 解法

解法多样：记下第一种，

# 解法一：递归思想
# 如果当前跳了一阶，还剩余n-1阶
# 如果当前跳了两阶，还剩余n-2阶
# 分别对n-1阶与n-2阶求次数，再相加
def jumpFloor(number):
	if number in (1, 2):
		return number
	return jumpFloor(number-1)+jumpFloor(number-2)

a = jumpFloor(10)
print(a)


# 解法二：循环实现，避免阶数过大造成时间超限
def jumpFloor(number):
    if number == 1 or number == 2:
        return number
    n, m = 1, 2
    for i in range(number-2):
    	result = m + n
    	n, m = m, result
    return result

a = jumpFloor(10)
print(a)


# 解法三：公式
# 设n级台阶，跳了z次，x次跳一阶，y次跳两阶。
# >>> z = x + y
# >>> n = 2*x + y

# @param {integer} n
# @return {integer}
def climbStairs(n):
    def fact(n):
        result=1
        for i in range(1,n+1):
            result*=i
        return result
    total=0
    # for i in range(n/2+1):	# float不能作为range的参数
    for i in range(n//2+1):
        total+=fact(i+n-2*i)/fact(i)/fact(n-2*i)
    return total

a = climbStairs(10)
print(a)

三、拷贝

3.1 拷贝实例

下面代码运行后，a、b、c、d四个变量的值，描述错误的是？

import copy
a = [1, 2, 3, 4, ['a', 'b']]
b = a
c = copy.copy(a)
d = copy.deepcopy(a)
a.append(5)
a[4].append('c')
#判断a，b,c,d分别是什么？

以下答案错误的是？
a ==  [1,2, 3, 4, ['a', 'b', 'c'], 5]
b ==  [1,2, 3, 4, ['a', 'b', 'c'], 5]
c ==  [1,2, 3, 4, ['a', 'b', 'c']]
d ==  [1,2, 3, 4, ['a', 'b', ‘c’]]

正确答案: D 你的答案: C (错误)

解析：

 import copy
a = [1, 2, 3, 4, ['a', 'b']] 
b = a     # 引用，除非直接给a重新赋值，否则a变则b变，b变则a变
c = copy.copy(a)   # 浅复制，只会拷贝父对象， 不会拷贝父对象中的子对象，所以若a的子对象变则c 变,但是父对象变c不会变
d = copy.deepcopy(a) #深拷贝，完全拷贝，完全独立于原对象，a变也不变
a.append(5) # 改变父对象
a[4].append('c')  #改变父对象中的 ['a', 'b']子对象

# a=[1, 2, 3, 4, ['a', 'b','c'],5] 
b=[1, 2, 3, 4, ['a', 'b','c'],5] 
c=[1, 2, 3, 4, ['a', 'b','c']] 
d=[1, 2, 3, 4, ['a', 'b']]

考察：赋值、深拷贝、浅拷贝

直接赋值:相当于指针值，赋值对象与被赋值对象一样，一起变化
浅拷贝：只拷贝父类对象，不拷贝子类对象，比如list中的元素即为父类对象，子类对象为list中的dict
深拷贝：父类对象和子类对象均拷贝

3.2 对象的赋值

都是进行对象引用（内存地址）传递，即‘’ b is a‘’ ，a 变 b 也变

b = a: 赋值引用，a 和 b 都指向同一个对象。

3.3 浅拷贝

会创建一个新的对象,即 “c is not a” ，但是，对于对象中的元素，浅拷贝就只会使用原始元素的引用（内存地址），也就是说”c[i] is a[i]” b = a.copy(): 浅拷贝, a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象（是引用）。

当我们使用下面的操作的时候，会产生浅拷贝的效果：

使用切片[:]操作
使用工厂函数（如list/dir/set）
使用copy模块中的copy()函数

3.4 深拷贝

会创建一个新的对象，即”d is not a” ，并且对于对象中的元素，深拷贝都会重新生成一份（有特殊情况，下面会说明），而不是简单的使用原始元素的引用（内存地址）b = copy.deepcopy(a): 深度拷贝, a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。

拷贝的特殊情况

其实，对于拷贝有一些特殊情况：

对于非容器类型（如数字、字符串、和其他’原子’类型的对象）没有拷贝这一说

如果元祖变量只包含原子类型对象，则不能深拷贝

3.5 拷贝例如

kvps = { '1' : 1, '2' : 2 }
theCopy = kvps.copy()
kvps['1'] = 5
sum = kvps['1'] + theCopy['1']
print sum

运行结果？

正确答案: C
1
2
6
10
An exception is thrown

解析：

在 Python2 和 Python3 中，copy() 方法的意义相同，均为返回一个浅复制的 dict 对象，而浅复制是指只拷贝父对象，不会拷贝对象的内部的子对象，即两个 dict 父对象 kvps 与 theCopy 相互独立，但对它们内部子对象的引用却是共享的，所以 kvps['1'] 的改变不影响 theCopy['1'] 的值（因为改变的是父对象的值）。

顺便一提，深复制是指完全拷贝父对象与子对象，即都相互独立。

注意，这里的子对象不是子类的对象，而是在父对象中的二级对象。

四、set

4.1 题

nums=set([1,1,2,2,3,3,3,3,3,4])

print len(nums)

问输出什么？答案是4

解析：

set 类型的特性是会移除集合中重复的元素，因此变量 nums 实际上等于：

1	`nums` `=` `{1,` `2,` `3,` `4}`

因此数据的长度为 4，故选C。详情可参考：

https://www.liaoxuefeng.com/wiki/1016959663602400/1017104324028448

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

4.2 set

要创建一个set，需要提供一个list作为输入集合：

>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}

注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的。

重复元素在set中自动被过滤：

>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}

通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：

>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.add(4)
>>> s
{1, 2, 3, 4}

通过remove(key)方法可以删除元素：

>>> s.remove(4)
>>> s
{1, 2, 3}

set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}

set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。试试把list放入set，看看是否会报错。

五、复数

5.1 复数的表示

关于Python中的复数，下列说法错误的是
正确答案: C

表示复数的语法是real + image j
实部和虚部都是浮点数
虚部必须后缀j，且必须是小写
方法conjugate返回复数的共轭复数

解析：

选项 A：Python 中复数的表示方法；
选项 B：复数的实部与虚部均为浮点数；
选项 C：虚部的后缀可以是 “j” 或者 “J”；
选项 D：复数的 conjugate 方法可以返回该复数的共轭复数。

5.2 复数相关知识

Python语言中有关复数的概念：

1、虚数不能单独存在，它们总是和一个值为0.0的实数部分一起构成一个复数
2、复数由实数部分和虚数部分构成
3、表示虚数的语法：real+imagej或者real+imageJ，小写大写均可
4、实数部分和虚数部分都是浮点数
5、虚数部分必须有后缀j或J

复数的内建属性：

复数对象拥有数据属性，分别为该复数的实部和虚部。
复数还拥有conjugate方法，调用它可以返回该复数的共轭复数对象。
复数属性：real(复数的实部)、imag(复数的虚部)、conjugate()（返回复数的共轭复数）

六、判断

6.1 try与except

Python中的异常处理和try，except的用法 https://blog.csdn.net/u012080686/article/details/81940211

try试图执行try中的代码，如果执行正确则不运行except
如果try中出现系统错误，则运行except

a = 1
try:
    a += 1
expect:
    a += 1
else:
    a += 1
finally:
    a += 1
print a

先整理下代码，异常捕捉，try和expect 只执行一个，else和finally都要执行。

首先执行try子句，没有异常那么执行else语句，finally语句是无论如何让都要执行的。

所以a的值为4

6.2 except作用

输出异常:

七、全局变量

7.1 全局变量用法

https://blog.csdn.net/lmseo5hy/article/details/81704426

全局变量是编程语言中常见的一种变量，通过全局定义，可以是某对象函数创建，也可以是本程序任何位置创建，能够被本程序中的所有对象或函数进行引用，全局变量的定义有利于程序的变量共享，简化了添加和修改的程序。

声明法

该方法是直接在当前模块中进行全局变量定义声明，使用global的声明方式，再进行引用！

    OLD_URL='http://oldboyedu.com'
     
    def bb():
        global OLD_URL
        OLD_URL = OLD_URL +'#m'
    if __name__=='__main__':
        bb()
        print OLD_URL
     
    #输出：
    http://oldboyedu.com#m

模块法

该方法是把全局变量定义在一个单独模块中，然后在需要使用的全局模块中将定义的全局变量模块导入

    #gl.py  全局变量模块定义
    GL_A=‘hello’
    GL_B=’world’
     
    #test.py 全局变量引用模块
    import gl
     
    def hello_world()
        print gl. GL_A， GL_B
    输出helloworld

7.2 全局变量实例

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author:sking
#Python3 局部变量与全局变量作用域

name01 = '1'
name02 = '1'
def test(name,name02): #因为函数内的name01被golbal成了全局变量，所有此时的函数参数name不能写成name01
    global name01
    name01 = '2'
    name02 = '2'

test(name01, name02)
print(name01, name02)#2 1 #函数内的name01被声明成了全局变量，所以函数内的name01可以修改函数外部name01的值

#列表、字典、集合、类是可以直接在局部变量里面修改的
#字符串、整数是不可以直接在局部变量里面修改的
name03 = 1
name04 = ['a','b','c']
def test2(name,name02): #因为函数内的name01被golbal成了全局变量，所有此时的函数参数name不能写成name01
    name03 = 2
    name04[0] = 'd'
test2(name03, name04)
print(name03) #1 #整数是不可以直接在局部变量里面修改的
print(name04) #['d', 'b', 'c'] #列表、字典、集合、类是可以直接在局部变量里面修改的

7.3 python的变量顺序

作用顺序：https://blog.csdn.net/baidu_15113429/article/details/77368069

当前作用域局部变量->外层作用域变量->当前模块中的全局变量->python内置变量

Local ==> Enclosing ==> Global ==> Builtin

运行结果：

7.4 global与nonlocal

gloabl用于声明全局变量，并且对全局变量进行更改

gcount = 0 #可以看作当前作用模块中的全局变量

def global_test():
    print(gcount) #来自于全局变量

def global_counter():
    global gcount    #加入global声明以声明全局变量并且对其值进行更改
    gcount += 1
    return gcount

def global_counter_test():
    print(global_counter()) 
    print(global_counter())
    print(global_counter())
global_counter_test()

程序运行结果为

1
2
3

nonlocal关键字用来在函数或其他作用域中使用外层(非全局)变量。

def make_counter():  
    count = 0

    def counter():
        nonlocal count   #引用外层的变量
        count += 1
        return count
    return counter

def make_counter_test():
    mc = make_counter()
    print(mc())
    print(mc())
    print(mc())
make_counter_test()

输出

1
2
3

祥瑞Coding

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
python基础知识及应用(二)输入输出|递归|深浅拷贝|全局变量|复数

目录一、python输入输出二、迭代2.1 输入与输出2.2 解法三、拷贝3.1 拷贝实例3.2 对象的赋值3.3 浅拷贝3.4 深拷贝3.5 拷贝例如四、set4.1 题4.2 set五、复数5.1 复数的表示5.2 复数相关知识六、判断6.1 try与except6.2 except作用七、全局变量7.1 ...
复制链接

扫一扫