Python（一）基础语法

Posted on | 本文阅读 次

注：初学Python，记录的是Python和Java不同、重点的地方。

参考资料：廖雪峰python教程和菜鸟教程。

一、变量赋值

Python在任意数据类型之间都可以相互赋值，例如字符串和整数型相互赋值

1
2
3
4
>>>a = 11
>>>print 'a =',a
>>>a = "python"
>>>print 'a =',a

结果：

1
2
a = 11
a = python

与Python不同的是在Java中，不同的数据类型是不能相互赋值，如

1
2
int x ；
x = “Python”  //整数型和字符串不能相互赋值。

二、List集合

方法 实现
创建List集合 List = [123,’java’,’kotlin’,”php”]
查看List集合 List 回车
查看集合中的某个元素 List[i]， i为集合元素的索引，如查看第一个元素，List[0]
在集合末尾添加元素 List.append(name)
在指定位置添加元素 List.insert(i,name)，i：索引位置，name：待插入元素名称
删除集合末尾元素 List.pop()
删除指定元素 List.pop(i)，i：索引位置
替换指定元素 List[i] = name，i：索引位置，name：要替换元素名称
集合包含集合 List = [‘name1’,[‘name2’,’name3’],’name4’]

案例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#创建
>>> List = [123,'java','kotlin',"php"]
#查询全部
>>> List
[123, 'java', 'kotlin', 'php']
#指定查询
>>> List[0]
123
#末尾添加元素
>>> List.append('python')
>>> List
[123, 'java', 'kotlin', 'php', 'python']
#添加元素到位置1
>>> List.insert(1,'true')
>>> List
[123, 'true', 'java', 'kotlin', 'php', 'python']
#删除末尾元素
>>> List.pop()
'python'
>>> List
[123, 'true', 'java', 'kotlin', 'php']
#删除索引为1的元素
>>> List.pop(1)
'true'
>>> List
[123, 'java', 'kotlin', 'php']
#替换索引为1的元素
>>> List[1] = 'python'
>>> List
[123, 'python', 'kotlin', 'php']
>>> 
#集合中包含集合
>>> List = ['123',['99','py'],'java']
>>> List
['123', ['99', 'py'], 'java']

三、Tuple数组

tuple为元组，与List不同的是tuple一经创建，数组中的元素就不可改变，不能增加和删除，具有稳定性。
| 方法| 实现 |
|—–|—–|
| 创建tuple | tuple = (‘python’,’java’,123)，需要注意的是创建的tuple如果只有一个元素，则需要在元素后加上逗号”,”，如：tuple = (123,)

四、循环

4.1：for… in…循环

相当于Java的增强for循环。如：循环打印List集合

1
2
3
4
5
6
7
8
>>> List=[123,'python','java']
>>> for i in List:
...     print(i)
... 
123
python
java
>>>

4.2、while循环

与Java while循环相似。如：求和运算：

1
2
3
4
5
6
7
8
>>> x=10
>>> sum =0
>>> while x > 0:
     sum = sum + x
     x = x - 1
>>> print sum
55
>>>

五、Dict

dict 为dictionary， 相当于java中的map，以键值对的方式存储。注意的是需要选择不可变对象作为key，如字符串。 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没有动，只是其内部的一部分值被修改了。
    python 函数的参数传递：
  • 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
  • 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响。
    python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
5.1、存储方式：
1
>>> dict = {'python':1,'java':2,'php':3}

或者指定key存储：

1
>>>dict[100] = 'html'

5.2、判断元素是否存在dict中：

①：

1
2
3
4
>>> 'java' in dict
True
>>> 'sps' in dict
False

java属于dict中的元素，返回true，不属于则返回false。
②：通过dict的get方法

1
2
>>> dict.get('java')
2

若get元素存在，则返回它的值，若不存在，则返回空

5.3、删除元素：

如删除dict中的java

1
2
3
4
5
>>> dict.pop('java')
2
>>> dict
{'python': 1, 'php': 3}
>>>

六、函数

6.1、定义函数

def function（参数1，参数2）：
pass
return

1
2
3
4
5
6
7
#定义函数
def te(str):
    print(str)
    return

#调用函数
te("python")

6.2、pass
  • 表示不做任何处理；
  • 表示占位符；
    当程序不做任何处理时，需要加上pass，缺少会出现程序错误。
6.3、参数
  • 必备参数
    Python中的必备参数和Java类似，在定义了函数包含了参数，那么在调用此函数时不可缺少参数。
  • 关键字参数
    Python通过调用关键字函数来传入参数，且传入多个参数时，顺序不需要和函数中的参数顺序一致。如：
    1
    2
    3
    4
    5
    6
    #定义函数
    def te(str,int):
        print(str,int)
        return
    #调用函数
    te(int = 1,str = "python")

结果

1
python 1

定义函数的参数顺序为（str，int），结果表明与顺序无关。

  • 默认参数
    如果默认参数的值没有被传入，则会被默认为默认值。如：
    1
    2
    3
    4
    5
    6
    7
    #定义函数
    def te(str,int = 10):
        print(str,int)
        return
    #调用函数
    te(int=1,str="python")
    te(str="java")

结果：

1
2
python 1
java 10

七、切片

所谓切片，就是截取一个片段。例如有一个集合List = [0,1,2,3,4,5,6,7]，包含8个数字，切片可截取0到6,3到6…等随意数字。
0-7.png

问题 结果
截取2-6中的数据：
3, 4, 5]|
1
2
3
4
5
6
7
8
9
10
|截取前5个数据：```List[0:5] 或者List[ : 5]```，0可以省略    |  [0, 1, 2, 3, 4] |
|截取最后一个数据：```List[-1：]```    |  [7] |
|截取最后三个数据：```List[-3：] ```  | [5, 6, 7]|
|前6个数每两个取一个数据：```List[ : 6 : 2]  ``` | [0, 2, 4]|
|所有数每两个取一个数据：```List[ :  : 2] ```  | [0, 2, 4, 6]|
从问题一的结果可以得知，截取数据索引是从2开始，6结束，但不包括6在内。
### 八、迭代
对容器内的各个元素进行访问。
例如有一个Dict集合dict = {'1':'python','2':99,'3' : 'java'}，对该集合进行不同类型的迭代。
#####8.1、迭代key：for key in dict：

dict = {‘1’:’python’,’2’:99,’3’ : ‘java’}
for key in dict:
print(key)

1
2
3
4
5
结果：
1
2
3
##### 8.2、迭代value：for value in dict.values():

for value in dict.values():
print(value)

1
2
3
4
5
结果：
python
99
java
#####  8.3、同时迭代key，value：for k,v in dict.items():

for k,v in dict.items():
print(k,v)
`
结果：
1 python
3 java
2 99

九、内置函数

9.1、列表生成器range
问题 结果
创建0-7的list列表：list(range(0,8)) [0, 1, 2, 3, 4, 5, 6, 7]
抽取0-7内每隔2个的列表：list(range(0,8,2)) [0, 2, 4, 6]
列表循环：[x / 2 for x in range(1,8)] [0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5]
抽取0-7内每隔2个的列表：list(range(0,8,2)) [0, 2, 4, 6]

十、最后

刚开始触碰python，和Java编写的格式还是不同，有时会像Java一样顺手补上分号和括号，不过慢慢地就习惯了。语法方面，就目前学习基础语法来看还是大同小异的，虽然有些许的不同，只要稍微注意下，不影响对语法的使用。python学习之路才刚刚踏进门，后续将不断体验Python的美妙之处。