python3练习

参考:http://www.runoob.com/python3/python3-tutorial.html


输入:

>>> a=input("input something:")
input something:hello world
>>> a
'hello world'


输出:加括号、不换行
>>> print("Hello, Python!")
Hello, Python!
>>> print "Hello, Python!"
  File "<stdin>", line 1
    print "Hello, Python!"
                         ^
SyntaxError: Missing parentheses in call to 'print'
>>> print("Hello, Python!", end="")
Hello, Python!>>>



指定解释器路径

在 Windows 下可以不写第一行注释:

#!/usr/bin/python3

第一行注释标的是指向 python 的路径,告诉操作系统执行这个脚本的时候,调用 /usr/bin 下的 python 解释器。

此外还有以下形式(推荐写法):

#!/usr/bin/env python3

这种用法先在 env(环境变量)设置里查找 python 的安装路径,再调用对应路径下的解释器程序完成操作。




help()函数

调用 python 的 help() 函数可以打印输出一个函数的文档字符串:

# 如下实例,查看 max 内置函数的参数列表和规范的文档
>>> help(max)
……显示帮助信息……

按下 : q 两个按键即退出说明文档

如果仅仅想得到文档字符串:

>>> print(max.__doc__)    # 注意,doc的前后分别是两个下划线
max(iterable, *[, default=obj, key=func]) -> value
max(arg1, arg2, *args, *[, key=func]) -> value



变量赋值

为多个变量分别赋值

>>> a,b=1,"test"
>>> a
1
>>> b
'test'


多个变量共享同一个内存空间

>>> a=b=1
>>> a
1
>>> b
1
>>> a==b
True




Python3中有六个标准的数据类型:
Number(数字)
String(字符串)
List(列表)
Tuple(元组)
Sets(集合)
Dictionary(字典)


数值的除法(/)总是返回一个浮点数,要获取整数使用//操作符。
>>> 4/2
2.0
>>> 4//2
2
>>> 4//3
1


自然字符串(不考虑转义字符\), 通过在字符串前加r或R
>>> a=r"this is a line with \n"
>>> a
'this is a line with \\n'


unicode字符串,加前缀u或U
>>> a=u"this is an unicode string, 中国"
>>> a
'this is an unicode string, 中国'


与C字符串不同的是,Python字符串不能被改变。向一个索引位置赋值,比如word[0] = 'm'会导致错误。
>>> a="python"
>>> a[0]
'p'
>>> a[0]="a"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment


创建集合
使用大括号 { } 或者 set() 函数创建集合,创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。


集合运算
print(a - b)     # a和b的差集
print(a | b)     # a和b的并集
print(a & b)     # a和b的交集
print(a ^ b)     # a和b中不同时存在的元素


Python数据类型转换
int(x [,base])
str(x)
chr(x)将一个整数转换为一个字符
ord(x)将一个字符转换为它的整数值
hex(x)将一个整数转换为一个十六进制字符串
oct(x)将一个整数转换为一个八进制字符串
eval(str)用来计算在字符串中的有效Python表达式,并返回一个对象
>>> a=eval("123")
>>> a
123
>>> type(a)
<class 'int'>
>>> a=eval("[1,2,3]")
>>> a
[1, 2, 3]
>>> type(a)
<class 'list'>


list内置函数

list.count(obj) 统计某个元素在列表中出现的次数
list.reverse() 反向列表中元素
list.copy() 复制列表
>>> original_list=[0,1,2,3,4,5,6,7,8]
>>> copy_list=original_list.copy()
>>> copy_list=copy_list+['a','b','c']
>>> print("original_list:",original_list)
original_list: [0, 1, 2, 3, 4, 5, 6, 7, 8]
>>> print("copy_list modify:",copy_list)
copy_list modify: [0, 1, 2, 3, 4, 5, 6, 7, 8, 'a', 'b', 'c']


深拷贝:
import copy
>>> a = [1,2,3,4]
>>> b = a
>>> d = copy.copy(a)
>>> b[0] = 'b'
>>> print(a,b,d)
['b', 2, 3, 4] ['b', 2, 3, 4] [1, 2, 3, 4]
>>> print(id(a),id(b),id(d))
140431253112712 140431253112712 140431253595720



tuple和list一样,只不过元素不能变,tuple存在的意义是可以作为dict的key


dict键必须不可变,所以可以用数字,字符串或元组充当,而用列表就不行
dict.copy()









python函数

参数传递:

不可变类型:类似 c++ 的值传递,如 整数、字符串、元组。如fun(a),传递的只是a的值,没有影响a对象本身。比如在 fun(a)内部修改 a 的值,只是修改另一个复制的对象,不会影响 a 本身。
可变类型:类似 c++ 的引用传递,如 列表,字典。如 fun(la),则是将 la 真正的传过去,修改后fun外部的la也会受影响
python 中一切都是对象,严格意义我们不能说值传递还是引用传递,我们应该说传不可变对象和传可变对象。

可更改(mutable)与不可更改(immutable)对象:
在 python 中,strings, tuples, 和 numbers 是不可更改的对象,而 list,dict 等则是可以修改的对象。
不可变类型:变量赋值 a=5 后再赋值 a=10,这里实际是新生成一个 int 值对象 10,再让 a 指向它,而 5 被丢弃,不是改变a的值,相当于新生成了a。
可变类型:变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改,本身la没有动,只是其内部的一部分值被修改了。


参数类型:
必需参数
关键字参数
默认参数
不定长参数


匿名函数lambda 



变量作用域
变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种,分别是:
L (Local) 局部作用域
E (Enclosing) 闭包函数外的函数中
G (Global) 全局作用域
B (Built-in) 内建作用域
以 L –> E –> G –>B 的规则查找,即:在局部找不到,便会去局部外的局部找(例如闭包),再找不到就会去全局找,再者去内建中找。

x = int(2.9)  # 内建作用域
 
g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部作用域

Python 中只有模块(module),类(class)以及函数(def、lambda)才会引入新的作用域,其它的代码块(如 if/elif/else/、try/except、for/while等)是不会引入新的作用域的,也就是说这这些语句内定义的变量,外部也可以访问,如下代码:

>>> if True:
...  msg = 'I am from Runoob'
... 
>>> msg
'I am from Runoob'
>>> 
如果将 msg 定义在函数中,则它就是局部变量,外部不能访问:





当内部作用域想修改外部作用域的变量时,就要用到global和nonlocal关键字了。
以下实例修改全局变量 num:

num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1() # 输出 1, 123
如果要修改嵌套作用域(enclosing 作用域,外层非全局作用域)中的变量则需要 nonlocal 关键字了,如下实例:

def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer() # 输出 100, 100

一种特殊情况:

>>> a = 10
>>> def aa():
...     a = a + 1
...     print(a)
...
>>> aa()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in aa
UnboundLocalError: local variable 'a' referenced before assignment

>>> a
10
>>> def aa():
...  global a
...  a = a + 1
...  print(a)
...
>>> aa()
11


>>> a = 1
>>> def aa():
...  b = a + 2
...  print(b)
...
>>> a
1
>>> aa()
3






模块

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

#!/usr/bin/python3
# Filename: using_name.py

if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')

运行输出如下:

$ python using_name.py
程序自身在运行
$ python
>>> import using_name
我来自另一模块
>>>


【为什么学PythonPython 是当今非常热门的语言之一,2020年的 TIOBE 编程语言排行榜中 ,Python名列第一,并且其流行度依然处在上升势头。 在2015年的时候,在网上还经常看到学Python还是学R的讨论,那时候老齐就选择了Python,并且开始着手出版《跟老齐学Python》。时至今日,已经无需争论。Python给我们带来的,不仅仅是项目上的收益,我们更可以从它“开放、简洁”哲学观念中得到技术发展路线的启示。 借此机会,老齐联合CSDN推出了本课程,希望能影响更多的人走进Python,踏入编程的大门。 【课程设计】 本课程共包含三大模块: 一、基础知识篇 内置对象和基本的运算、语句,是Python语言的基础。本课程在讲解这部分知识的时候,不是简单地将各种知识做简单的堆砌,而是在兼顾内容的全面性的同时,更重视向学习者讲授掌握有关知识的方法,比如引导学习者如何排查错误、如何查看和理解文档等。   二、面向对象篇 “面向对象(OOP)”是目前企业开发主流的开发方式,本课程从一开始就渗透这种思想,并且在“函数”和“类”的学习中强化面向对象开发方式的学习——这是本课程与一般课程的重要区别,一般的课程只在“类”这里才提到“对象”,会导致学习者茫然失措,并生畏惧,乃至于放弃学习。本课程则是从开始以“润物细无声”的方式,渗透对象概念,等学习到本部分的时候,OOP对学习者而言有一种“水到渠成”的感觉。   三、工具实战篇 在项目实战中,除了前述的知识之外,还会用到很多其他工具,至于那些工具如何安装?怎么自己做工具?有那些典型工具?都是这部分的内容。具体来说,就是要在这部分介绍Python标准库的应用以及第三方包的安装,还有如何开发和发布自己的工具包。此外,很多学习Python的同学,未来要么从事数据科学、要么从事Web开发,不论哪个方向,都离不开对数据库的操作,本部分还会从实战的角度,介绍如何用Python语言操作常用数据库。
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页