IPython与Jupyter
IPython 更具交互性的Python解释器,本身不提供任何计算或数据分析工具
重点:交互计算与软件开发将生产力最大化
Jupyter项目旨在设计一个适用于更多语言的交互式计算工具。IPython可以作为一个内核用于Jupyter中使用Python。
IPython自身以作为Jupyter开源项目的一个组件,后者提供交互性、探索性的高效环境。
isinstance 和 type 的区别在于:
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。
Python基本语法
基本数据类型
不可变数据类型:Number
String
Tuple
可变数据类型:List
Set
Dictionary
"""
不可变数据类型
"""
a = b = 10
b += 1
id(a) == id(b) # False
"""
可变数据类型:地址内容操作 Java unsafe C/C++ pointer
"""
list1=list2=[1,2,"33"]
list2.append(32)
id(list1)==id(list2) # False
参数列表(position和keyword)与可变参数列表(*args 和 *kwargs)
When a final formal parameter of the form **name
is present, it receives a dictionary
(see Mapping Types — dict
) containing all keyword arguments except for those corresponding to a formal parameter.
This may be combined with a formal parameter of the form *name
(described in the next subsection) which receives a tuple
containing the positional arguments beyond the formal parameter list. (*name
must occur before **name
.)
For example, if we define a function like this:
def cheeseshop(kind, *arguments, **keywords):
print("-- Do you have any", kind, "?")
print("-- I'm sorry, we're all out of", kind)
for arg in arguments:
print(arg)
print("-" * 40)
for kw in keywords:
print(kw, ":", keywords[kw])
It could be called like this:
cheeseshop("Limburger", "It's very runny, sir.",
"It's really very, VERY runny, sir.",
shopkeeper="Michael Palin",
client="John Cleese",
sketch="Cheese Shop Sketch")
and of course it would print:
-- Do you have any Limburger ?
-- I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
----------------------------------------
shopkeeper : Michael Palin
client : John Cleese
sketch : Cheese Shop Sketch
Note that the order in which the keyword arguments are printed is guaranteed to match the order in which they were provided in the function call.
A function definition may look like:
def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
----------- ---------- ----------
| | |
| Positional or keyword |
| - Keyword only
-- Positional only
where /
and *
are optional. If used, these symbols indicate the kind of parameter by how the arguments may be passed to the function : positional-only, positional-or-keyword, and keyword-only. Keyword parameters are also referred to as named parameters.
>>> def standard_arg(arg):
... print(arg)
...
>>> def pos_only_arg(arg, /):
... print(arg)
...
>>> def kwd_only_arg(*, arg):
... print(arg)
...
>>> def combined_example(pos_only, /, standard, *, kwd_only):
... print(pos_only, standard, kwd_only)
>>> pos_only_arg(arg=1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: pos_only_arg() got an unexpected keyword argument 'arg'
>>> kwd_only_arg(3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: kwd_only_arg() takes 0 positional arguments but 1 was given
>>> combined_example(1, 2, 3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: combined_example() takes 2 positional arguments but 3 were given
>>> combined_example(pos_only=1, standard=2, kwd_only=3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: combined_example() got an unexpected keyword argument 'pos_only'
Finally, consider this function definition which has a potential collision between the positional argument name
and **kwds
which has name
as a key:
def foo(name, **kwds):
return 'name' in kwds
> foo(1, **{'name': 2})
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: foo() got multiple values for argument 'name'
But using /
(positional only arguments), it is possible since it allows name
as a positional argument
and 'name'
as a key
in the keyword arguments
:
def foo(name, /, **kwds):
return 'name' in kwds
>>> foo(1, **{'name': 2})
True
Finally, the least frequently used option is to specify that a function can be called with an arbitrary number
of arguments
. These arguments will be wrapped up in a tuple
(see Tuples and Sequences). Before the variable number of arguments, zero or more normal arguments may occur.
Normally, these variadic arguments
will be last
in the list of formal parameters
, because they scoop up all remaining input arguments that are passed to the function. Any formal parameters
which occur after
the *args
parameter are ‘keyword-only’ arguments
, meaning that they can only be used as keywords
rather than positional
arguments.
>>> def concat(*args, sep="/"):
... return sep.join(args)
...
>>> concat("earth", "mars", "venus")
'earth/mars/venus'
>>> concat("earth", "mars", "venus", sep=".")
'earth.mars.venus'
The reverse situation occurs when the arguments are already in a list or tuple but need to be unpacked for a function call requiring separate positional arguments
.
For instance, the built-in range()
function expects separate start and stop arguments. If they are not available separately, write the function call with the *
-operator to unpack the arguments out of a list or tuple
:
>>> list(range(3, 6)) # normal call with separate arguments
[3, 4, 5]
>>> args = [3, 6]
>>> list(range(*args)) # call with arguments unpacked from a list
[3, 4, 5]
In the same fashion, dictionaries
can deliver keyword arguments with the **
-operator:
>>> def parrot(voltage, state='a stiff', action='voom'):
... print("-- This parrot wouldn't", action, end=' ')
... print("if you put", voltage, "volts through it.", end=' ')
... print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !