[已收纳]python之基础语法

15195775117

Python变量名不需要声明，

python是动态类型语言，变量类型可以随时变化；

以上两点都与IDL一样。

标准输出print()：

x=12.3

print(x)

x='abc'

print(x)

输出：

12.3

abc

使用type函数判断变量类型：

>>> type('x')

<class 'str'>

>>> type(666)

<class 'int'>

如果变量值一样，则其内存地址也一样：

>>> a=b=12

>>> id(a)

1563717440

>>> id(b)

1563717440

Python的整型比IDL强大，

不会有溢出的问题，

其整数位数是无限大的！

>>> x=32767

>>> x

32767

>>> x+1

32768

IDL> 32767+1

  -32768

IDL> 327678945612345413133333333312

  -8610619198004624064

>>> 327678945612345413133333333312

327678945612345413133333333312

八进制以0o或0O开头，

十六进制以0x或0X开头

数字转字符串：>>> str(123)

'123'

字符串连接用+号，与IDL同：

>>> '123'+'abc'

'123abc'

复数的表示：2+3j，虚部用j/J表示。

字符串用单引号或双引号表示，三引号包含的内容可以是连续的多行：

x="""123

456

abc

"""

print(x)

x='''123

456

abc

'''

print(x)

输出：

123

456

abc

123

456

Abc

布尔数值：False，True，分别对应0和1

布尔值为假的对象：

False,None,0,0.0,0J,

空字符串、空元组、空列表、空字典...

标准输入的函数，将键盘输入的内容赋予变量：

>>> x=input()

456

>>> x

'456'

一种熟悉的赋值方式，忘了名字：

>>> x=2 if 3>4 else 5

>>> x

5

在一行输出2个变量：

print('123','abc')

结果：123 abc

写文本：

x='''书山有路勤为径

学海无涯苦作舟'''

fp=open(r'C:\Users\Administrator\Desktop\py.txt','a+')

print(x,file=fp)

fp.close()

15195775117

粗略地比较下列表、元组、集合、字典：

列表：[1,2,3]

元组：(1,2,3)

集合：{1,2,3}

字典：{‘a’:1,’b’:2,3:’c’}

这些数据结构的基本操作，有空我再做一张表对比下

15195775117

集合

集合，与数学中概念类似，无重复。

格式{ , , ,}

直接创建集合：

>>> x={1,2,3}

>>> type(x)

<class 'set'>

集合是无序的，输出时顺序不一样是正常的。

用set函数将其他对象转为集合：

x='aabbccdd'

y=set(x)

print(y)

x=['ab','bc','bc','cd']

y=set(x)

print(y)

x=[1,2,3,4,5,4,3,2,1]

y=set(x)

print(y)

结果：

{'a', 'd', 'c', 'b'}

{'cd', 'bc', 'ab'}

{1, 2, 3, 4, 5}

发现：单一字符串会被拆掉

空集合不能用{}表示，{}只表示空字典，

x={}

y=set(x)

print(type(y))

结果：<class 'set'>

添加元素：

x={1,2,3}

x.add(4)

print(x)

结果：{1, 2, 3, 4}

删除元素：

x={1,2,3}

x.remove(2)

print(x)

结果：{1, 3}

a={1,2,3}

b={3,4,5}

交集print(a&b)

并集print(a|b)

差集print(a-b)

对称差集print(a^b)

结果：

{3}

{1, 2, 3, 4, 5}

{1, 2}

{1, 2, 4, 5}

注解：对称差集为蓝色部分：

                               
登录/注册后可看大图

15195775117

求余：7%3 结果1

取整除：7//3结果2

幂：2**3结果8

逻辑运算符：and;or;not

>>> not True

False

>>> not 1

False

>>> not 0

True

Python中没有switch，没有do while

break与continue与IDL一样

Python中None等于IDLd !value.f_nan

Python自带垃圾回收机制，与Java一样，所以del并不常用。

Python中比较运算符与C一样：

>;<;==;!=;>=;<=;

if 2>3:

    print('盗墓笔记')

else:

print('鬼吹灯')

多重选择：

x=10

if x<3:

    print('盗墓笔记')

elif x<8:

    print('鬼吹灯')

elif x<10:

    print('黄河鬼棺')

else:

print('藏海花')

While循环：

x=10

while x>1:

    print(x)

x=x-1

结果：10 9 8 ...3 2

Python的for循环与IDL的foreach一样：

a=[1,2,3]

for x in a:

print(x*2)

结果：2 4 6

输出字符串元素：

a='hfsoihgoias'

for x in a:

    print(x)

range相当于indgen，是整型索引数组。

range(5)是0,1,2,3,4

range(3,7)是3,4,5,6

range(5,20,3)是5 8 11 14 17

格式为range(start,end,step)，元素>=start，元素<end，所以不包含结尾值

a=range(10)

for x in a:

print(x*2)

输出：0 2 4 6 ......18

Python的索引与IDL一样，从0开始，可以用负值。

a='hfsoihgoias'

输出a中从2到8间隔取值：

print(a[2:9:2])

结果：sigi

连接：

a=[1,2,3]

b=[4,5,6]

x='abc'

y='opq'

print(a+b)

print(x+y)

结果：

[1, 2, 3, 4, 5, 6]

abcopq

a=[1,2,3]

x='abc'

print(a*3)

print(x*3)

结果：

[1, 2, 3, 1, 2, 3, 1, 2, 3]

Abcabcabc

判断某值是否是序列的元素：

a=[1,2,3]

x='abc'

print(2 in a)

print('c' in x)

print('t' in x)

输出：True True False

不在则用6 not in a

len()相当于IDL的n_elements()；

max()和min()求最值；

sum()相当于IDL的total();

sorted()相当于IDL的sort();

reversed()将序列反向;

list()将序列转为列表;

Python的列表元素类型可以是不同的：a=[1,'x',3]

创建空列表：x=[]

删除列表：del x

获取当前星期：

import datetime

x=datetime.datetime.now().weekday()

print(x)

今天周四，输出3

15195775117

For循环中使用enumerate，可以同时表示每个元素的索引和值

x='qwerty'

for p,v in enumerate(x):

    print(p,v)

0 q

1 w

2 e

3 r

4 t

5 y

Print不换行的方法：

x='qwerty'

for v in x:

print(v,end='')

结果：qwerty

列表a追加单个元素b：

a.append(b)或者a=a+b

据说，使用append比+效率高。

向列表指定位置插入元素用insert()（语法不明）

追加多个元素：

a=['1','2']

b=['4','5','6']

a.extend(b)

print(a)

['1', '2', '4', '5', '6']

extend和append不支持字符串。

感觉extend可以取代append。

修改元素：

a=['1','2']

a[0]='x'

print(a)

结果：['x', '2']

删除元素的方法：

a=[1,2,3,4,5,6,6,7,7,8,9]

按索引删除：

del a[2]

print(a)

结果：[1, 2, 4, 5, 6, 6, 7, 7, 8, 9]

a=[1,2,3,4,5,6,6,7,7,8,9]

按值删除：

a.remove(7)

print(a)

结果：[1, 2, 3, 4, 5, 6, 6, 7, 8, 9]

可见按值删除只删了一个！按值删除如果没有符合的值还会报错！

列表中某个值的元素有几个？

a=[1,2,3,4,5,6,6,7,7,8,9]

print(a.count(7))

结果：2

求某值首次出现的索引：

a=[1,2,3,4,5,6,6,7,7,8,9]

print(a.index(7))

结果：7

Python的index比IDL的where差很多嘛。

升序排列：

a=[1,2,3,2,1]

a.sort(reverse=False)

print(a)

结果：[1, 1, 2, 2, 3]

降序排列把False改为True。

对字符列表排序：

a=['cat','Tom','Angela','pet']

a.sort(reverse=False)

print(a)

a.sort(reverse=False,key=str.lower)

print(a)

结果：

['Angela', 'Tom', 'cat', 'pet']

['Angela', 'cat', 'pet', 'Tom']

key=str.lower表示不区分大小写，区分大小写会先排大写。

如果不想改变原列表，则使用sorted()，对a进行升序排序：

a=['cat','Tom','Angela','pet']

b=sorted(a,reverse=False,key=str.lower)

print(b)

结果：['Angela', 'cat', 'pet', 'Tom']

区分：sort是个方法，sorted是个函数

二维列表：

x=[[1,2,3],[4,5,6],

   [7,8,9]]

print(x)

可见换行比较自由

Python的列表可以用del删元素，可以用append添加元素，都会改变列表大小。

Python的二维表先行后列，与C同。

15195775117

元组篇

元组（tuple），是不可变的列表。

（python的“列表”似乎就是数组）。

元组的元素是不能修改的，但是元组名可以重新赋值：

>>> x=(1,2,'a','b')

>>> x[1]=9

修改元素会报错：

Traceback (most recent call last):

  File "<pyshell#20>", line 1, in <module>

    x[1]=9

TypeError: 'tuple' object does not support item assignment

整个修改没事：

>>> x=('a','p')

>>> x

('a', 'p')

列表用中括号，元组用小括号：列表=[ , , , ] 元组=( , , , )

元组也可以省去括号，例如：

>>> x=123,'asd','我'

>>> x

(123, 'asd', '我')

如果元组只有一个元素，则需要加逗号：

>>> x='asd',

>>> x

('asd',)

不加逗号就只是个字符串。

元组的元素可以是任何类型，包括元组类型。

一个元组中元素类型可以不同，因为元素之间没有关联。

新建空元组：x=()

>>> x='a',

>>> type(x)

<class 'tuple'>

强制转换：

>>> x=range(5)

>>> y=tuple(x)

>>> y

(0, 1, 2, 3, 4)

>>> x=['aa','bb']

>>> tuple(x)

('aa', 'bb')

删除元组：del x

输出元素的方式与列表一样：

>>> x=['aa','bb']

>>> x[1]

'bb'

>>> print(x[1])

bb

使用print输出时没有引号

前3 个元素：x[:3]

>>> x=(1,2,'a','b')

>>> x[:3]

(1, 2, 'a')

元组追加元素：

>>> x=('a','p')

>>> x+(123,456)

('a', 'p', 123, 456)

15195775117

字典


字典，是无序的列表；保存形式---“键值对”。
键是惟一的，值可以有多个。


Python的字典=Java/C++的Map对象


字典的格式与结构体十分相似：
>>> x={1:'a',2:'b','k':'浪花'}
>>> x
{1: 'a', 2: 'b', 'k': '浪花'}
通用结构为：
{key1:value1,key2:value2,......}
冒号前的叫“键”，冒号后的叫“值”。


与结构体不同的是，这里的键可以是很多类型，而不只是作为变量名。


空字典：{}



用2个列表或元组生成字典：
>>> keys=['k','h',123]
>>> values=[99,56,'GH']
>>> dict(zip(keys,values))
{'k': 99, 'h': 56, 123: 'GH'}
或
keys=('k','h',123)
values=(99,56,'GH')
d=dict(zip(keys,values))

新建方法之一：
>>> x=dict(a=3,b=6,c='c')
>>> x
{'a': 3, 'b': 6, 'c': 'c'}

创建值为空的字典：
>>> keys=['a','b',99]
>>> d=dict.fromkeys(keys)
>>> d
{'a': None, 'b': None, 99: None}

输出字典元素是按键，不是按索引：
>>> x
{'a': 3, 'b': 6, 'c': 'c'}
>>> x['a']
3

用get()获取元素：
>>> x
{'a': 3, 'b': 6, 'c': 'c'}
>>> x['a']
3
>>> x.get('a',999)
3
>>> x.get('d',999)
999
格式：get(键，备用值)
如果键存在，就返回对应的值，如果不存在，就返回备用值，没有备用值，就返回None。
>>> x.get('d')
>>> type(x.get('d'))
<class 'NoneType'>

换行符\n
>>> print('abc\ndf')
abc
df

查询字典内容，用items()方法：
x={'a': 3, 'b': 6, 'c': 'c'}
for i in x.items():
        print(type(i),i)
结果以元组形式给出：
<class 'tuple'> ('a', 3)
<class 'tuple'> ('b', 6)
<class 'tuple'> ('c', 'c')
这方法的方便之处可能是可以获得键吧：
x={'a': 3, 'b': 6, 'c': 'c'}
for i in x.items():
        print(i[0])


还有个自动分离键和值的写法：
x={'a': 3, 'b': 6, 'c': 'c'}
for i,j in x.items():
        print(i,j)
结果：
a 3
b 6
c c

字典的keys()和values()方法可以提取键和值：
x={'a': 3, 'b': 6, 'c': 'c'}
k=x.keys()
print(k)
for i in k:
    print(i)
v=x.values()
print(v)
for i in v:
print(i)
结果：
dict_keys(['a', 'b', 'c'])
a
b
c
dict_values([3, 6, 'c'])
3
6
C

字典中添加元素：
x={'a': 3, 'b': 6, 'c': 'c'}
x['d']=999
print(x)
结果：{'a': 3, 'b': 6, 'c': 'c', 'd': 999}
如果新增的键与原有的重名，相当于修改。

删除键值对：
x={'a': 3, 'b': 6, 'c': 'c'}
del x['a']
print(x)
结果：{'b': 6, 'c': 'c'}

又是那隻貓

你如果拿IDL、C++或者java的思路来学Python，基本很难精通

15195775117

又是那隻貓 发表于 2019-4-23 18:24
你如果拿IDL、C++或者java的思路来学Python，基本很难精通

初学嘛，比较下异同，以后熟能生巧自然就行了

15195775117

关于列表、元组、集合、字典、字符串的一些对比、总结：

	列表	元组	集合	字典	字符串
强制转换		tuple()	set()		str()
示例	[1,2,'xyz']	(1,2,'xyz')	{1,2,'xyz'}	{a:1,b:2,3:c}	'hglsj515'
空	[]	()		{}	''
添加元素	列表+新元素或列表.extend(列表2)	元组+元组2	集合.add（新元素）	字典[新键]=新值	合并：'abc'+'jkl'
删除元素	del 列表[索引] 或 列表.remove(元素)		集合.remove(某元素)	del 字典[键]
整个删除	del 列表	del 元组	del 集合	del 字典