python 编程语言基础技术框架

python标识符
身份 id方法查看唯一标示符,内存地址

>>> a = "str"
>>> b = 2
>>> id(a)
140223954701072
>>> id(b)
36610848
查看变量的数据类型;
>>> type(b)
<type 'int'>
>>> type(a)
<type 'str'>

要素1：python将所有数据存为内存对象

python中，变量事实上是指向内存对象的引用
动态类型:在任何时刻，只要需要，某个对象引用都可以重新引用一个不同的对象(可以是不同的数据类型)
内建函数type()用于返回给定数据项的数据类型
"="用于将变量名与内存中的某对象绑定:如果对象事先存在，就直接进行绑定；否则，则由"="创建引用对象

>>> name = "tom"
>>> test = "tom"
>>> id(name)
140223953962208
>>> id(test)
140223953962208

要素2：对象引用(变量)
变量的命令规则
1、只能包含字母、数字和下划线，且不能以数字开头
2、区分字母大小写
3、禁止使用保留字
python2与python3的保留字有所不同
命令惯例
1、以单一下划线开头变量名(_x)不会被from module import *语句导入
2、前后有下划线的变量名(_x_)是系统定义的变量名，对python解释器有特殊的意义
3、以两个下划线开头但结尾没有下划线的变量名(__x)是类的本地变量
4、交互式模式下，变量名"_"用于保存最后表达式的结果
注意:变量名没有类型，对象才有

>>> 1 + 1
2
>>> print _
2

要素3:组合数据类型
一、数据结构:通过某种方式(例如对元素进行编号)组织在一起的数据元素的集合
二、python常用的组合数据类型
序列类型
1、列表:使用[]创建，如['call','me','Ishmeal','.'],列表是可变对象;支持原处修改;

>>> l1=["This","is","a","pig"]
>>> l1[0]
'This'
>>> l1[0][0]
'T'

并且指向的内存对象;列表在内存中的地址空间保持不变;
注意:列表中存储的是指针;而指针指向的是内存对象的数据元素;
列表中的数据元素本身是不可变的;变的是引用;

>>> print l1
['This', 'is', 'a', 'sheep']
>>> id(l1)
140223953808704
>>> l1[3]="pig"
>>> id(l1)
140223953808704
>>> print l1
['This', 'is', 'a', 'pig']

2、元组:使用()创建，如('one','two')，元组是不可变对象；
>>> t1=("This","is","a","pig")
>>> t1[0]
'This'
>>> t1[0][0]
'T'

3、字符串也属于序列类型
集合类型
集合
映射类型
字典

字符串切片:

>>> name = "firefox"
>>> name[0]
'f'
>>> name[0:2]
'fi'
>>> name[0:3]
'fir'
>>> name[1:2]
'i'
>>> name[:2]
'fi'
>>> name[2:]
'refox'

指定字符串的步进;
>>> name[0:7:2]
'frfx'
要素3 二: 组合数据类型
列表是可变序列，元组是不可变序列
python中，组合数据类型也是对象，因此其可以嵌套
['hello','world',[1,2,3]]
实质上，列表和元组并不真正存储数据，而是存放对象引用
python对象可以具有其可以被调用的特定"方法(函数)"
元组、列表以及字符串等数据类型是"有大小的"，也即，其长度可以使用内置函数len()测量;

 

要素4: 逻辑操作符

一、逻辑运算时任何程序设计语言的基本功能

二、Python提供了4组逻辑运算

1、身份操作符

　　is：判定左端对象引用是否相同于右端对象引用；也可以与none进行；

>>> name = "Tom"
>>> test = "Tom"
>>> name is test
True
>>> test = "firefox"
>>> name is test
False
>>> type(name) is type(test)
True

2、比较操作符

　　<,>,<=,>-,!=,==
成员操作符
　　in,或者 not in :测试成员关系
逻辑运算符
　　and,or,not 

要素5:控制流语句

一、控制流语句是过程式编程语言的基本控制机制

二、Python的常见控制流语句

if

if boolean_expression1 :
    suite1
elif boolean_expression2:
    suite2
...

 

while

while boolean_expreesion：
        suite

for .. in

for variable in iterable:
    suite 

 

try

要素6 :算数操作符

一、Python提供了完成的算术操作集

二、很多的Python数据类型也可以使用增强的赋值操作符，如+=、-=等；

三、同样的功能，使用增强赋值操作符的性能较好；

四、Python的int类型是不可变的，因此，增强类型赋值的实际过程是创建了一个新的对象来存储结果后将变量名执行了重新绑定

 

要素7 :输出/输出

现实中，具有实际功能的程序必须能够读取输入(如从键盘或文件中)，以及产生输出，并写到终端或文件中；

python的输入/输出

输出
python3: print()函数
python2: print语句
输入
input()
raw_input() 
>>> raw_input("plz input a name:")
plz input a name:firefox
'firefox'
>>> a= raw_input("plz input a name:")
plz input a name:firefox
>>> print a
firefox

python解释器提供了3中标准文件对象，分别是标准输入、标准输出和标准错误，它们在sys模块中分别以sys.stdin、sys.stdout、sys.stderr形式提供；

print 接受一个逗号分隔的对象列表，并为行尾自动添加一个换行符，如果不需要，则在最后个元素后添加逗号;

>>> a="this is a"
>>> b="pig"
>>> print a,b
this is a pig

print "string %format1 %format2 ...." %(variable1,variable2...)

%后面可以使用修饰符,(如果有，则只能按照如下顺序)

%[name][flags][width][.precision]typecode

位于括号中的一个属于后面的字典的键名，用于选出一个具体想

下面标志中的一个或多个

_:表示左对齐，默认右对齐
+:表示包含数字符号，整数也会带"+"
0:表示一个零填充

 

>>> num = 7.9
>>> print "The num is %f" % num
The num is 7.900000
>>> print "The num is %d" % num
The num is 7
>>> num2 = 7.12
>>> print num
7.9
>>> print num2
7.12
>>> print "The nums are %d and %f" % (num, num2)
The nums are 7 and 7.120000
>>> print "The nums are %d and %f" % (num, 3.1)
The nums are 7 and 3.100000
>>> print "The nums are %e and %f" % (num, 3.1)
The nums are 7.900000e+00 and 3.100000 
>>> print "The name is %s." %name
The name is Tome.
>>> print "The name is %s." % num
The name is 7.9.
#数据类型转换:  
1、显示转换:
>>> test = str(num)
>>> type(test)
<type 'str'>
>>> type(num)
<type 'float'>
>>> print num
7.9

Python 字符串格式化使用 "字符 %格式1 %格式2 字符"%(变量1,变量2)，%格式表示接受变量的类型。简单的使用例子如下
# 例：字符串格式化
Name = '17jo'  
print 'www.%s.com'%Name  
>> www.111cn.net
Name = '17jo'
Zone = 'com'
print 'www.%s.%s'%(Name,Zone)
>> www.111cn.net
字符串格式化时百分号后面有不同的格式符号，代表要转换的不同类型，具体的表示符号如下面所示。
格式符号  表示类型
%s  字符串
%d/%i  十进制整数或长整数
%u  无符号整数或十进制整数
%o  八进制整数或长整数
%x/%X     十六进制整数或长整数(%X:大写字母)         
%e/%E  科学计数;浮点数
%f/%F  浮点数
%%  输出%
%   字面量%
%c   单个字符
%r   同repr()生成的字符串
  %g,G  指数小于-4或更高精度是使用%e或%E,否则使用%f
格式符号为数字时前面可以加为数和补缺位如：%[0][总位数][.][小数位数]来设定要转换的样式，具体使用方法如下：
# 例：数字格式化
nYear = 2018
nMonth = 8
nDay = 18
# 格式化日期 %02d数字转成两位整型缺位填0 
print  '%04d-%02d-%02d'%(nYear,nMonth,nDay)   
>> 2018-08-18  # 输出结果
fValue = 8.123
print '%06.2f'%fValue # 保留宽度为6的2位小数浮点型
>> 008.12   # 输出
print '%d'%10  # 输出十进制
>> 10
print '%o'%10  # 输出八进制
>> 12
print '%02x'%10  # 输出两位十六进制，字母小写空缺补零
>> 0a
print '%04X'%10  # 输出四位十六进制，字母大写空缺补零
>> 000A
print '%.2e'%1.2888 # 以科学计数法输出浮点型保留2位小数
>> 1.29e+00
到此，我们已经演示了怎样替换指定的字段。我们还可以通过在格式化指示符后面添加一个冒号来进行精确格式化。例如：
python: format 
# Field 0: left justify, pad to 15 characters
# Field 1: right justify, pad to 6 characters
fmt = '{0:15} ${1:>6}'
fmt.format('Registration', 35) ->
 'Registration $ 35'
fmt.format('Tutorial', 50) ->
 'Tutorial $ 50'
fmt.format('Banquet', 125) ->
 'Banquet $ 125'
格式化指示符可以通过嵌套进行引用。
fmt = '{0:{1}}'

width = 15
fmt.format('Invoice #1234', width) ->
 'Invoice #1234 '
  
width = 35
fmt.format('Invoice #1234', width) ->
 'Invoice #1234 '
可以指定所需长度的字符串的对齐方式。
效果字符：
< （默认）左对齐
> 右对齐
^ 中间对齐
= （只用于数字）在小数点后进行补齐
格式化指示符可以包含一个展示类型来控制格式。例如，浮点数可以被格式化为一般格式或用幂来表示。
>>> '{0:g}'.format(3.75)
 '3.75'
>>> '{0:e}'.format(3.75)
 '3.750000e+00'
展示类型有很多。2.6的文档里有完整的列表。这里列出一些示例。
'b' - 二进制。将数字以2为基数进行输出。
'c' - 字符。在打印之前将整数转换成对应的Unicode字符串。
'd' - 十进制整数。将数字以10为基数进行输出。
'o' - 八进制。将数字以8为基数进行输出。
'x' - 十六进制。将数字以16为基数进行输出，9以上的位数用小写字母。
'e' - 幂符号。用科学计数法打印数字。用'e'表示幂。
'g' - 一般格式。将数值以fixed-point格式输出。当数值特别大的时候，用幂形式打印。
'n' - 数字。当值为整数时和'd'相同，值为浮点数时和'g'相同。不同的是它会根据区域设置插入数字分隔符。
'%' - 百分数。将数值乘以100然后以fixed-point('f')格式打印，值后面会有一个百分号。
类和类型可以定义一个__format__()方法来控制怎样格式化自己。它会接受一个格式化指示符作为参数：
def __format__(self, format_spec):
 if isinstance(format_spec, unicode):
  return unicode(str(self))
 else:
  return str(self)
还有一个内置的format()方法可以用来格式化一个值。它会调用类型的__format__()方法，并将格式化指示符作为参数传进去。
>>> format(75.6564, '.2f')


要素8:函数的创建与调用
1、python使用def语句定义函数
2、函数可参数化，通过传递不同的参数来调用
3、每个python函数都有一个返回值，默认为none，也可以使用"return value"明确定义返回值
4、def语句会创建一个函数对象，并同时创建一个指向函数对象引用
　　函数也是对象，可以存储在组合数据类型中，也可以作为参数传递给其它函数
　　callable()可用于测试函数是否可调用 ():调用运算符

>>> def testFunc(arg1):
... print arg1
...
>>> callable(testFunc)
True
>>> testFunc("hello world!")
hello world!

>>> test = "firefox"
>>> testFunc(test)
firefox