“Python”的版本间差异

来自Shiyin's note
跳到导航 跳到搜索
（未显示同一用户的72个中间版本）
第2行： 第2行：
[[Python2 vs Python3]]
[[Python2 vs Python3]]


[[python的安装]]
[[python安装和配置]]


[[Python程序的调试]]
[[Python程序的调试]]


[[Python程序的测试]]
[[ipython]]

[[jupyter]]


参考：W3school [https://www.w3school.com.cn/python/index.asp]


=容器=
=容器=
第44行： 第43行：
:* pop (删除指定位置元素，并返回该元素，同时修改列表)，实现栈的功能，入栈（push），出栈（pop），Python里面没有push，用append功能实现
:* pop (删除指定位置元素，并返回该元素，同时修改列表)，实现栈的功能，入栈（push），出栈（pop），Python里面没有push，用append功能实现
:* remove，reverse，sort （sort的用法要注意，参考书的39页）,sorted
:* remove，reverse，sort （sort的用法要注意，参考书的39页）,sorted
*改变列表的类型
:a=[0.3,0.7]
b=list(map(int,a))
b=list(map(round,a)) # 四舍五入


===元组===
===元组===
第52行： 第55行：
* list: 把元祖装换为列表
* list: 把元祖装换为列表
* 元组貌似没有什么用处，列表基本满足所有需要
* 元组貌似没有什么用处，列表基本满足所有需要


===字典===
*字典用大括号生成，字典的元素是items，每个元素有keys，values
:如果不定义keys，默认的keys就是index，那么字典的里面的values可以直接用index调用
dic={'a','b','c'}
dic[2]
* a，b 是两个数组，把 a和b映射起来变成一个字典
:dic=dict(zip(a,b))
* 如果对一个列表c，希望用dict来查值，并赋给另外一个列表d
d=[dict(x) for x in a]
* 下面的方法将用于合并两个字典。
def merge_two_dicts(a, b):
c = a.copy() # make a copy of a
c.update(b) # modify keys and values of a with the ones from b
return c
# 在 Python 3.5 或更高版本中，我们也可以用以下方式合并字典：
def merge_dictionaries(a, b)
return {**a, **b}

*字典默认值通过 Key 取对应的 Value 值，可以通过以下方式设置默认值。如果 get() 方法没有设置默认值，那么如果遇到不存在的 Key，则会返回 None。
d = {'a': 1, 'b': 2}
print(d.get('c', 3)) # 3


===字符串===
===字符串===
*%s%d%f （字符串，整数，浮点数）[https://blog.csdn.net/qq_37482544/article/details/63720726]
*不可变
* join & split
* A='python‘
A=['1','2']
* % 格式化
B='+'.join(A)
C-B,split('+')


====字符串前“b”,“r”,“u”,“f”的作用====
==集合==
*无序不重复集 set [http://blog.csdn.net/business122/article/details/7541486]
*参见[https://www.jb51.net/article/176601.htm]


*字符串前加 b 表示这是一个 bytes 对象, chararray 中的赋值默认就是带b的
==数组==
例: response = b'Hello World!' b' '
网络编程中，服务器和浏览器只认bytes 类型数据, 如：send 函数的参数和 recv 函数的返回值都是 bytes 类型. 在 Python3 中，bytes 和 str 的互相转换方式是
str.encode(‘utf-8')
bytes.decode(‘utf-8')
* 字符串前加 u，后面字符串以 Unicode 格式 进行编码
* 字符串前加 r，去掉反斜杠的转移机制
例：r"\n\n\n\n”　　表示一个普通生字符串 \n\n\n\n，而不表示换行了。
* 字符串前加 f， 表示在字符串内支持大括号内的python 表达式
例： print(f'{name} done in {time.time() - t0:.2f} s')

===数组 ndarray===
*numpy中有个数组ndarray的数据结构 [http://blog.csdn.net/sunny2038/article/details/9002531]
*numpy中有个数组ndarray的数据结构 [http://blog.csdn.net/sunny2038/article/details/9002531]
:array() 可以将列表等转化为数组
:array() 可以将列表等转化为数组
:asarray()和array差不多，但是不一定需要复制
:asarray()和array差不多，但是不一定需要复制


*如何把两个数组合并为一个数组
=函数=
:np.concatenate((a, b), axis=0)
*在参数名之前使用一个星号，就是让函数接受任意多的位置参数。[http://blog.csdn.net/qinyilang/article/details/5484415]

==lambda 函数==
==集合==
*无序不重复集 set [http://blog.csdn.net/business122/article/details/7541486]
>>> a = [11,22,33,44,11,22]
>>> b = set(a)
>>> b
set([33, 11, 44, 22])
>>> c = [i for i in b] #注意这个用法很方便
>>> c

=类=
[[Python中的类]]
* 如何查看类的属性 https://www.cnblogs.com/klchang/p/7296058.html

=控制语句=
==条件==
*<expression1> if <condition> else <expression2>
:如果为真 执行 expression1，否则执行 expression2

==异常==
try:
x=input('enter the value of x')
y=1/x
except:
print(error)
else:
print(1/x)
finally:
print('whatever x, I do not care')

=运算=
* // ：除法取整
==位运算符==
*& 按位与，都为1，结果为1，有一个0，就为0 a & b
*| 按位或，都为0，结果为0，有一个1，就为1 a | b
*^ 按位异或，不同，结果为1，相同，就为0 a ^ b
*~ 按位取反，1变0，0变1 ~a
*<< 左移动，高位丢弃，低位补0 a << 2，左移2位
*>> 右移动，丢弃右移位数，高位补0 a >> 3，右移3位

=函数、类、模块=
*函数以 def(): 来定义
*类以 class(): 来定义
*一般一个模块指一个同名文件（文件中有一般有一个__init__()函数），或者同名文件夹（文件夹下有一个__init__.py）
:* import一个文件中的某个函数，或者类， from modular import sth
:* import一个文件夹中的某个文件： from modular import file
:* import一个文件夹中的某个文件中的某个函数或者类： from modular.file imprt sth
*模块可以被reload（文件修改之后需要重新加载）
import importlib
importlib.reload(module)

==函数==
*函数的输出用returm
*lambda 函数
>>> g = lambda x:x+1
>>> g = lambda x:x+1
看一下执行的结果：　
看一下执行的结果：　
　　>>>g(1)
　　
　　>>>2
>>>g(1)
>>>2
可以这样认为,lambda作为一个表达式，定义了一个匿名函数，上例的代码x为入口参数，x+1为函数体:f(x)=x+1
参见http://www.cnblogs.com/evening/archive/2012/03/29/2423554.html


可以这样认为,lambda作为一个表达式，定义了一个匿名函数，上例的代码x为入口参数，x+1为函数体:f(x)=x+1, 参见[http://www.cnblogs.com/evening/archive/2012/03/29/2423554.html]
=模块=
*glob 查找文件位置
*os 系统的一些变量
:dir=os.getenv('bc03_dir')


===参数===
==内部变量，魔方方法==
*参见 [https://www.jianshu.com/p/98f7e34845b5]
*__file__
*函数参数中的冒号是参数的类型建议符，告诉程序员希望传入的[[实参的类型]]。函数后面跟着的箭头是函数返回值的类型建议符，用来说明该函数返回的值是什么类型。
:查找源文件位置 print(ppxf.__file__)
*五种参数
这五种参数可以组合使用，但参数定义的顺序必须是：位置参数-->默认参数-->可变参数-->命名关键字参数-->关键字参数

*位置参数
*默认参数
:重点：默认参数必须指向不变对象
*可变参数
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
:可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple
>>> nums = [1, 2, 3]
>>> calc(*nums)
: 实参里调用*nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用，而且很常见。

*关键字参数
def person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)
:关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
: 实参中的**extra用法表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
:参见 参数中的*和** [https://blog.csdn.net/cadi2011/article/details/84871401]
*命名关键字参数（这个我比较喜欢）
如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：
def person(name, age, *, city, job):
print(name, age, city, job)
:和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符，后面的参数被视为命名关键字参数。
:命名关键字参数可以设定默认值，但是不能不给,可能这是和默认参数的区别

===函数名===
*是否可以用变量做为函数名？参见 [pythontab.com/html/2013/pythonhexinbiancheng_0813/540.html]

==类==


*类的实例的保存和载入，pickle
output = open('data.pkl', 'wb')
# Pickle dictionary using protocol 0.
pickle.dump(data1, output)
output.close()

pkl_file = open('data.pkl', 'rb')
data1 = pickle.load(pkl_file)
pkl_file.close()

===内部变量，魔方方法===
* my_class.__module__ #查看我的这个类在哪个模块中定义的
*__name__,__main__
*__name__,__main__
:if __name__ == '__main__': test()
:if __name__ == '__main__': test()
第92行： 第230行：
*__doc__ （文档）
*__doc__ （文档）
:print(copy.copy.__doc__)
:print(copy.copy.__doc__)
*__repr__
:python的每部命名方法
*__str__
:使用print输出对象时，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据
*__add__,__bool__,__float__
:每个object都有，所以这几个命令对任何object都可以操作
[https://blog.csdn.net/pdstar/article/details/90900944]

==模块==
*模块一般由文件或者文件夹来定义，默认在site-packages/下面，如果是文件夹，那下面应该有__init__.py文件；
*模块名.__file__
:查找源文件位置 print(ppxf.__file__)


[[脚本和模块]]
[[脚本和模块]]


=画图=
=画图=
*参见[[Matplotlib]]
*ipython中事先执行 %matplotlib
*交互式，数据可视化Bokeh
*http://www.scipy-lectures.org/intro/matplotlib/matplotlib.html
*还有spotify下的Charitfy（基于Bokeh）
*[[matplotlib]][http://www.cnblogs.com/wei-li/archive/2012/05/23/2506940.html]
*pylab combines pyplot with numpy into a single namespace. This is convenient for interactive work, but for programming it is recommended that the namespaces be kept separate, e.g.:
import numpy as np
import matplotlib.pyplot as plt
x = np.arange(0, 5, 0.1);
y = np.sin(x)
plt.clf() #clear the current figure
plt.subplot(211)
plt.plot(x, y)
plt.show()


=输入输出=
* options for the color characters are:
'r' = red
'g' = green
'b' = blue
'c' = cyan
'm' = magenta
'y' = yellow
'k' = black
'w' = white
* Options for line styles are
'-' = solid
'--' = dashed
':' = dotted
'-.' = dot-dashed
'.' = points
'o' = filled circles
'^' = filled triangles


*marker style [https://matplotlib.org/api/markers_api.html]
*pmesh,pcolormesh: 画二维的平面分布的图
*colorbar

=输入输出=


==格式输出==
==格式==
*print("%10.3f"% (356.08977))
*print("%10.3f"% (356.08977))
*在输出ndarray的时候，设置输出的数的精度
*在输出ndarray的时候，设置输出的数的精度
:np.set_printoptions(precision=2)
:np.set_printoptions(precision=2)


*浮点数转换为字符串保留两位小数
:value = 100.000
final = "{:.2f}".format(value)
str2='%.2f'%value


==文件输入==
===ascii 文件===
*[[pandas]] 中的read_table
*[[numpy]]中的genfromtext
:ppxf 中根据该程序写了一个接口程序 readcol


===[[python中二进制文件的读取]]===


==文件输出==
==文件输出==
第145行： 第275行：
k=1000
k=1000
l=10
l=10
s='line'

*格式输出
f.write("{0:4d} {1:d}\n".format(k,l)) #str.format 用法 0是第一个参数，1是第二个参数，：后面是格式， write只能是字符串
f.write("{0:4d} {1:d}\n".format(k,l)) #str.format 用法 0是第一个参数，1是第二个参数，：后面是格式， write只能是字符串
f.write('line 1: {:0>3d},{:.2f}'.format(a,b)+'\n') #0表示左边补0, >表示右对齐，3表示宽为3个字符
f.close()
f.write("line 1:%3d %4.2f" %(a,b)) #C语言格式，感觉更友好
f = open("chain.dat", "a") #接着写

*默认格式输出
data=[s,k,l]
f.write(','.join([str(i) for i in data])+'\n')
print(s.k,l,file=f)

*关闭文件
f.close()
===写成csv文件===
*利用[[pandas]]的dataframe

===表格输出===
table={'XCENTER': [0.2, 0.44]}
ascii.write(table, formats={'XCENTER': '%12.5f'})


=Packages=
=Packages=
*[[astropy]]


*[[scipy]]
==[[numpy]]==


*[[numpy]]
==[[pandas]]==


==[[scipy]]==
===[[astropy]]===

*glob 查找文件位置

*os 系统的一些变量
:dir=os.getenv('bc03_dir') 等同于 os.environ.get()

:os.getcwd() #获取当前目录的绝对路径


*命令行解析工具 Argparse [https://www.cnblogs.com/jianboqi/archive/2013/01/10/2854726.html]


*消光：sfdmap and extinction
*消光：sfdmap and extinction
:https://github.com/kbarbary/sfdmap
:https://github.com/kbarbary/sfdmap
*healpy
*healpy

=开发环境=
==[[ipython]]==
==[[jupyter]]==
==[[spyder]]==

=特殊字符=
*None
:在python中 None, False, 空字符串"", 0, 空列表[], 空字典{}, 空元组()都相当于False ，即：
not None == not False == not '' == not 0 == not [] == not {} == not ()


=链接=
=链接=
*带下划线变量的意义 [http://www.cnblogs.com/elie/p/5902995.html]
*带下划线变量的意义 [http://www.cnblogs.com/elie/p/5902995.html]
*tqdm 生成一个进度条
:from tqdm import tqdm

2024年7月7日 (日) 14:10的版本

Python2 vs Python3

python安装和配置

Python程序的调试

Python程序的测试

参考：W3school [1]

容器

  • container（数据结构）
  • 有3种: 序列，映射，集合

序列(sequence)

  • 序列有6总（列表，元组，字符串，Unicode字符串，buffer对象，xrange对象）
  • 序列的索引从0开始，对序列分片时包括开头，不包括结尾，比如A[3:4]只包括A列表的第四个成员
  • 序列的加号操作，[1,2,3]+[4,5,6] = [1,2,3,4,5,6]
  • 乘号参考加号 [1,2]*2 = [1,2,1,2]

通用序列操作

  • 索引，分片（slice），加，乘，迭代，最大，最小，长度
  • 索引从0开始，最后一个元素是-1（从右向左索引）
  • 分片: 访问倒数3个 A[-3:]，访问正数3个A[:3]
  • 步长为2访问 A[0:10:2]，步长可以为负，从右向左。
  • 相加 [1,2]+[3,4]-->[1,2,3,4]
  • 相乘 [1,2]*3 --> [1,2,1,2,1,2]
  • A=[None]*10 生成长度为10的空的列表
  • 成员资格：in，布尔运算符
  • len （长度），min，max
  • enumerate: 对一个列表或数组既要遍历索引又要遍历元素时
for index，text in enumerate(list): 
  print index ,text

列表

  • 列表的元素可以修改，字符串不能
  • x=[1,1,1],x[1]=2
  • del x[1]
  • x[1:1]=[2,3,4] 分片赋值，注意这相当于插入
  • 列表方法
  • append, count, extend, index, insert
  • pop (删除指定位置元素，并返回该元素，同时修改列表)，实现栈的功能，入栈（push），出栈（pop），Python里面没有push，用append功能实现
  • remove，reverse，sort （sort的用法要注意，参考书的39页）,sorted
  • 改变列表的类型
a=[0.3,0.7]
b=list(map(int,a))
b=list(map(round,a)) # 四舍五入

元组

  • 不可变序列
  • （1,2,3) (1，)
  • 比如3*(40+2) 和3*(40+2,)的差别
  • tuple函数：把列表转换为元组
  • list: 把元祖装换为列表
  • 元组貌似没有什么用处，列表基本满足所有需要


字典

  • 字典用大括号生成，字典的元素是items，每个元素有keys，values
如果不定义keys，默认的keys就是index，那么字典的里面的values可以直接用index调用
dic={'a','b','c'}
dic[2]
  • a，b 是两个数组，把 a和b映射起来变成一个字典
dic=dict(zip(a,b))
  • 如果对一个列表c，希望用dict来查值，并赋给另外一个列表d
d=[dict(x) for x in a]
  • 下面的方法将用于合并两个字典。
def merge_two_dicts(a, b):
   c = a.copy()   # make a copy of a 
   c.update(b)    # modify keys and values of a with the ones from b
   return c
  1. 在 Python 3.5 或更高版本中，我们也可以用以下方式合并字典：
def merge_dictionaries(a, b)
  return {**a, **b}
  • 字典默认值通过 Key 取对应的 Value 值，可以通过以下方式设置默认值。如果 get() 方法没有设置默认值，那么如果遇到不存在的 Key，则会返回 None。
d = {'a': 1, 'b': 2}
print(d.get('c', 3)) # 3

字符串

  • %s%d%f （字符串，整数，浮点数）[2]
  • join & split
A=['1','2']
B='+'.join(A)
C-B,split('+')

字符串前“b”,“r”,“u”,“f”的作用

  • 字符串前加 b 表示这是一个 bytes 对象, chararray 中的赋值默认就是带b的
例: response = b'Hello World!' b' '

网络编程中，服务器和浏览器只认bytes 类型数据, 如：send 函数的参数和 recv 函数的返回值都是 bytes 类型. 在 Python3 中，bytes 和 str 的互相转换方式是 

str.encode(‘utf-8')
bytes.decode(‘utf-8')
  • 字符串前加 u，后面字符串以 Unicode 格式 进行编码
  • 字符串前加 r，去掉反斜杠的转移机制
例：r"\n\n\n\n”　　表示一个普通生字符串 \n\n\n\n，而不表示换行了。
  • 字符串前加 f， 表示在字符串内支持大括号内的python 表达式
例： print(f'{name} done in {time.time() - t0:.2f} s')

数组 ndarray

  • numpy中有个数组ndarray的数据结构 [4]
array() 可以将列表等转化为数组
asarray()和array差不多，但是不一定需要复制
  • 如何把两个数组合并为一个数组
np.concatenate((a, b), axis=0)

集合

  • 无序不重复集 set [5]
>>> a = [11,22,33,44,11,22]
>>> b = set(a)
>>> b
set([33, 11, 44, 22])
>>> c = [i for i in b] #注意这个用法很方便
>>> c

类

Python中的类

控制语句

条件

  • <expression1> if <condition> else <expression2>
如果为真 执行 expression1，否则执行 expression2

异常

try:
  x=input('enter the value of x')
  y=1/x
except:
  print(error)
else:
  print(1/x)
finally:
 print('whatever x, I do not care')

运算

  • // ：除法取整

位运算符

  • & 按位与，都为1，结果为1，有一个0，就为0 a & b
  • | 按位或，都为0，结果为0，有一个1，就为1 a | b
  • ^ 按位异或，不同，结果为1，相同，就为0 a ^ b
  • ~ 按位取反，1变0，0变1 ~a
  • << 左移动，高位丢弃，低位补0 a << 2，左移2位
  • >> 右移动，丢弃右移位数，高位补0 a >> 3，右移3位

函数、类、模块

  • 函数以 def(): 来定义
  • 类以 class(): 来定义
  • 一般一个模块指一个同名文件（文件中有一般有一个__init__()函数），或者同名文件夹（文件夹下有一个__init__.py）
  • import一个文件中的某个函数，或者类， from modular import sth
  • import一个文件夹中的某个文件： from modular import file
  • import一个文件夹中的某个文件中的某个函数或者类： from modular.file imprt sth
  • 模块可以被reload（文件修改之后需要重新加载）
import importlib
importlib.reload(module)

函数

  • 函数的输出用returm
  • lambda 函数
>>> g = lambda x:x+1

看一下执行的结果：　 　　 

>>>g(1)
>>>2

可以这样认为,lambda作为一个表达式，定义了一个匿名函数，上例的代码x为入口参数，x+1为函数体:f(x)=x+1, 参见[6]

参数

  • 参见 [7]
  • 函数参数中的冒号是参数的类型建议符，告诉程序员希望传入的实参的类型。函数后面跟着的箭头是函数返回值的类型建议符，用来说明该函数返回的值是什么类型。
  • 五种参数

这五种参数可以组合使用，但参数定义的顺序必须是：位置参数-->默认参数-->可变参数-->命名关键字参数-->关键字参数

  • 位置参数
  • 默认参数
重点：默认参数必须指向不变对象
  • 可变参数
def calc(*numbers):
   sum = 0
   for n in numbers:
       sum = sum + n * n
   return sum
可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple
>>> nums = [1, 2, 3]
>>> calc(*nums)
实参里调用*nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用，而且很常见。
  • 关键字参数
def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)
关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
实参中的**extra用法表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
参见 参数中的*和** [8]
  • 命名关键字参数（这个我比较喜欢）

如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下： 

def person(name, age, *, city, job):
    print(name, age, city, job)
和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符，后面的参数被视为命名关键字参数。
命名关键字参数可以设定默认值，但是不能不给,可能这是和默认参数的区别

函数名

  • 是否可以用变量做为函数名？参见 [pythontab.com/html/2013/pythonhexinbiancheng_0813/540.html]

类

  • 类的实例的保存和载入，pickle
output = open('data.pkl', 'wb')
# Pickle dictionary using protocol 0.
pickle.dump(data1, output) 
output.close()

pkl_file = open('data.pkl', 'rb')
data1 = pickle.load(pkl_file)
pkl_file.close()

内部变量，魔方方法

  • my_class.__module__ #查看我的这个类在哪个模块中定义的
  • __name__,__main__
if __name__ == '__main__': test()
  • __init__ （初始化方法 ）
def __init__(self)
  • __all__ （显示可见功能）
copy.__all__
  • __doc__ （文档）
print(copy.copy.__doc__)
  • __repr__
python的每部命名方法
  • __str__
使用print输出对象时，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据
  • __add__,__bool__,__float__
每个object都有，所以这几个命令对任何object都可以操作

[9]

模块

  • 模块一般由文件或者文件夹来定义，默认在site-packages/下面，如果是文件夹，那下面应该有__init__.py文件；
  • 模块名.__file__
查找源文件位置 print(ppxf.__file__)

脚本和模块

画图

  • 参见Matplotlib
  • 交互式，数据可视化Bokeh
  • 还有spotify下的Charitfy（基于Bokeh）

输入输出

格式

  • print("%10.3f"% (356.08977))
  • 在输出ndarray的时候，设置输出的数的精度
np.set_printoptions(precision=2)
  • 浮点数转换为字符串保留两位小数
value = 100.000
final = "{:.2f}".format(value) 
str2='%.2f'%value

文件输入

ascii 文件

ppxf 中根据该程序写了一个接口程序 readcol

python中二进制文件的读取

文件输出

f = open("chain.dat", "w")
k=1000
l=10
s='line'
  • 格式输出
f.write("{0:4d} {1:d}\n".format(k,l)) #str.format 用法 0是第一个参数，1是第二个参数，：后面是格式， write只能是字符串
f.write('line 1: {:0>3d},{:.2f}'.format(a,b)+'\n') #0表示左边补0, >表示右对齐，3表示宽为3个字符
f.write("line 1:%3d %4.2f" %(a,b)) #C语言格式，感觉更友好
  • 默认格式输出
 data=[s,k,l]
 f.write(','.join([str(i) for i in data])+'\n')
 print(s.k,l,file=f)
  • 关闭文件
f.close()

写成csv文件

表格输出

table={'XCENTER': [0.2, 0.44]}
ascii.write(table, formats={'XCENTER': '%12.5f'})

Packages

numpy

pandas

scipy

astropy

  • glob 查找文件位置
  • os 系统的一些变量
dir=os.getenv('bc03_dir') 等同于 os.environ.get()
os.getcwd() #获取当前目录的绝对路径


  • 命令行解析工具 Argparse [10]
  • 消光：sfdmap and extinction
https://github.com/kbarbary/sfdmap
  • healpy

开发环境

ipython

jupyter

spyder

特殊字符

  • None
在python中 None, False, 空字符串"", 0, 空列表[], 空字典{}, 空元组()都相当于False ，即：
not None == not False == not  == not 0 == not [] == not {} == not ()

链接

  • 带下划线变量的意义 [11]
  • tqdm 生成一个进度条
from tqdm import tqdm
取自“http://202.127.29.3/~shen/wiki/index.php?title=Python&oldid=4094”