Python学习_python中键盘输入的+号是字符串么

一.python学习

python就是个解析语言，跟其他编译语言C、C++、java都不同
1.1基于ubuntu的Python环境搭建

lwh@lwh:~/work/study/AI$ sudo apt-get install python3.6
1

1.2输出hello word
解释：step01:

lwh@lwh:~/work/study/AI$ vim Study01.py
1

step02:文件中输入下面内容前面数字是用来做解释的

  #! /usr/bin/python
  # -*- coding: UTF-8 -*-
  print("hello,word")
  print("你好，世界")
1
2
3
4

第一行#! /user/bin/python 脚本语言的第一行，只对linux及unix有用，这里是告诉系统用那个解析器解析，有了这个的时候就可以直接在终端执行./Study01.py，这个也可以告诉你这个py文件支持的Python版本，因为你系统可能装了几个Python，但你用那个指定的执行可以在这里指定如：

  #! /usr/bin/python3
  # -*- coding: UTF-8 -*-
  print("hello,word")
  print("你好，世界")
1
2
3
4

第二行：# -- coding: UTF-8 --是告诉编译器采用的编码格式，也可以用#coding=utf-8来说明，python3.x已经默认采用utf-8编码格式了，但如果是2.x则有中文时需要加编码格式
第三、四行就是python中的接口函数，这里就是输出函数

二python中的基础语法

这里就是死记硬背的东西
2.1标识符
所谓标识符就是函数名、变量名等
在python中标识符有字母、数字、下划线组成，但标识符不能以数字开头，
在python中的标识符是区分大小写的
以下划线开头的标识符是有特殊意义的，
以单下划线开头_foo代表不能被访问的类属性，需通过类提供的接口访问，不能通过form xxx import *导入
以双下划线开头__foo代表类的私有成员
以双下划线开头结尾__foo__代表类中特殊方法专用的表示如:__init__类的构造函数
2.2保留字符
这些保留字不能被单独用作常数或变数等其他标识符
and exec not
assert finally or
break for pass
class from print
continue global raise
def if return
del import try
elif in while
else is with
except lambda yield
2.3行和缩进
python中用缩进来表示代码块，其他语言用大括号{}表示,
这个缩进必须严格执行，负责代码将会出错
2.3多行
python语句一般以新行作为语句的结束但我们可以用反斜杠()类延续上一行的内容
如

#! /user/bin/python
# -*- coding: UTF-8 -*-
print("hello,word")
print("你好，世界")
print("hello,\
word")
1
2
3
4
5
6

语句中包含 [], {} 或 () 括号就不需要使用多行连接符

days = ['Monday', 'Tuesday', 'Wednesday',
        'Thursday', 'Friday']
1
2

2.4 python中的引号
Python 可以使用引号( ’ )、双引号( " )、三引号( ‘’’ 或 “”" ) 来表示字符串，引号的开始与结束必须是相同类型的。
其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。

word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""
1
2
3
4

2.5 python的注释
python中单行注释采用 # 开头。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名：test.py

# 第一个注释
print ("Hello, Python!")  # 第二个注释
1
2
3
4
5
6

python 中多行注释使用三个单引号(’’’)或三个双引号(""")。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名：test.py


'''
这是多行注释，使用单引号。
这是多行注释，使用单引号。
这是多行注释，使用单引号。
'''

"""
这是多行注释，使用双引号。
这是多行注释，使用双引号。
这是多行注释，使用双引号。
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.6 python空行
函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。
记住：空行也是程序代码的一部分。
2.7 等待用户输入函数

#!/usr/bin/python
# -*- coding: UTF-8 -*-

raw_input("按下 enter 键退出，其他任意键显示...\n")
1
2
3
4

2.8 同一行显示多条语句

#!/usr/bin/python

import sys; x = 'runoob'; sys.stdout.write(x + '\n')
1
2
3

三.python中的变量

3.1python中的变量是在内存中的值，这就意味着创建变量时会在内存中开辟一个空间，基于变量类型，解析器会分配指定的内存，并决定什么数据可以存储在内存中，
3.2 python中的变量赋值不需要类型声明，
Python 中的变量赋值不需要类型声明。
每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
等号 = 用来给变量赋值。
等号 = 运算符左边是一个变量名，等号 = 运算符右边是存储在变量中的值。例如：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串
 
print(counter)
print(miles)
print(name)
1
2
3
4
5
6
7
8
9
10

python是允许多个变量赋值的
a = b = c = 1
以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。
您也可以为多个对象指定多个变量。例如：
a, b, c = 1, 2, “john”
以上实例，两个整型对象 1 和 2 分别分配给变量 a 和 b，字符串对象 “john” 分配给变量 c。
3.3 标准数据类型

1. Numbers（数字）
2. String（字符串）
3. List（列表）
4. Tuple（元组）
5. Dictionary（字典)
   3.3.1 整形
   int（有符号整型）
   long（长整型[也可以代表八进制和十六进制]）
   float（浮点型）
   complex（复数）
   整形
   a = -1
   a = 2
   a = 02
   a= 0x12
   长整型
   长整型也可以使用小写 l，但是还是建议您使用大写 L，避免与数字 1 混淆。Python使用 L 来显示长整型
   浮点型
   a = 0.0
   a = 2.2
   a = -32.54e100
   a = -90.
   复数
   Python 还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型
   3.14j
   9.322e-36j
   -.6545+0J
   3e+26J
   Python字符串
   python的字串列表有2种取值顺序:
   从左到右索引默认0开始的，最大范围是字符串长度少1
   从右到左索引默认-1开始的，最大范围是字符串开头
   
   如果你要实现从字符串中获取一段子字符串的话，可以使用 [头下标:尾下标] 来截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。
   [头下标:尾下标] 获取的子字符串包含头下标的字符，但不包含尾下标的字符。
   加号（+）是字符串连接运算符，星号（*）是重复操作。如下实例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
str = 'Hello World!'
 
print str           # 输出完整字符串
print str[0]        # 输出字符串中的第一个字符
print str[2:5]      # 输出字符串中第三个至第六个之间的字符串
print str[2:]       # 输出从第三个字符开始的字符串
print str * 2       # 输出字符串两次
print str + "TEST"  # 输出连接的字符串
1
2
3
4
5
6
7
8
9
10
11

Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：

列表
List(列表)是python中使用最频繁的数据类型，
列表可以实现大多数集合类的数据结构实现，他支持数字、字符、字符串，甚至包含列表
列表用中括号([])表示，是python中最通用的复合类型
列表中的值切割可以用变量[头下标:尾下标]，就可以截取相应列表，从左到右默认从0开始，从右到左默认从-1开始，下标为空表示取到头或尾，
在python中截取到的列表中的值任然以列表的形式返回,获取指定列表中的值以值的形式返回
加号 + 是列表连接运算符，星号 * 是重复操作

#! /user/bin/python
# -*- coding: UTF-8 -*-

list = [1,2.3,'234test',2.0,12233]

print(list)
print(list[0])
print(list[1:2])
print(list[-2:-4])
print(list[-4:-2])
print(list[-1:])
print(list + list[-4:-2])
print(list * 2)

1
2
3
4
5
6
7
8
9
10
11
12
13
14

输出：

lwh@lwh:~/work/study/AI$ python Study03.py 
[1, 2.3, '234test', 2.0, 12233]
1
[2.3]
[]
[2.3, '234test']
[12233]
[1, 2.3, '234test', 2.0, 12233, 2.3, '234test']
[1, 2.3, '234test', 2.0, 12233, 1, 2.3, '234test', 2.0, 12233]
1
2
3
4
5
6
7
8
9

元祖
元组是另一个数据类型，类似于 List（列表）。
元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

#! /usr/bin/python
# -*- coding: utf-8 -*-

tuple = ('test','1234',2,4.3,345)

print(tuple)
print(tuple[2])
print(tuple[2:3])
print(tuple[-4:-1])
print(tuple[:])
1
2
3
4
5
6
7
8
9
10

输出：

lwh@lwh:~/work/study/AI$ python Tuple.py 
('test', '1234', 2, 4.3, 345)
2
(2,)
('1234', 2, 4.3)
('test', '1234', 2, 4.3, 345)
1
2
3
4
5
6

字典
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
#! /usr/bin/python

# -*- coding: UTF-8 -*-

dict = {}
dict['one'] = "this is one"
dict[2] = "this is two"
tinydict = {'name':'runoob','code':'12334','dept':'sales'}

print(dict['one'])
print(dict[2])
print(tinydict)
print(tinydict['dept'])
print(tinydict.keys())
print(tinydict.values())
1
2
3
4
5
6
7
8
9
10
11
12
13

输出：

this is one
this is two
{'dept': 'sales', 'code': '12334', 'name': 'runoob'}
sales
['dept', 'code', 'name']
['sales', '12334', 'runoob']
1
2
3
4
5
6

Python数据类型转换

int(x [,base]) 将x转换为一个整数
long(x [,base] ) 将x转换为一个长整数
float(x) 将x转换到一个浮点数
complex(real [,imag])创建一个复数
str(x)将对象 x 转换为字符串
repr(x)将对象 x 转换为表达式字符串
eval(str)用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)将序列 s 转换为一个元组
list(s)将序列 s 转换为一个列表
set(s)转换为可变集合
dict(d)创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)转换为不可变集合
chr(x)将一个整数转换为一个字符
unichr(x)将一个整数转换为Unicode字符
ord(x)将一个字符转换为它的整数值
hex(x)将一个整数转换为一个十六进制字符串
oct(x)将一个整数转换为一个八进制字符串