欢迎光临
我们一起进阶

python-前端的的JavaScript(六)内置对象和方法

掩体阅读(13)

JavaScript中的所有事物都是对象:字符串、数字、数组、日期,等等。在JavaScript中,对象是拥有属性和方法的数据。
对象只是带有属性和方法的特殊数据类型。
创建对象:

通过 JavaScript,您能够定义并创建自己的对象。
var person=new Object(); // 创建一个person对象
person.name=”Alex”; // person对象的name属性
person.age=18; // person对象的age属性

Date对象
创建Date对象
//方法1:不指定参数
var d1 = new Date();
console.log(d1.toLocaleString());

//方法2:参数为日期字符串
var d2 = new Date("2004/3/20 11:12");
console.log(d2.toLocaleString());
var d3 = new Date("04/03/20 11:12");
console.log(d3.toLocaleString());

//方法3:参数为毫秒数
var d3 = new Date(5000);
console.log(d3.toLocaleString());
console.log(d3.toUTCString());

//方法4:参数为年月日小时分钟秒毫秒
var d4 = new Date(2004,2,20,11,12,0,300);
console.log(d4.toLocaleString());  //毫秒并不直接显示
Date对象的方法:
var d = new Date(); 
//getDate()                 获取日
//getDay ()                 获取星期几 从星期天开始
//getMonth ()               获取月(0-11)
//getFullYear ()            获取完整年份
//getYear ()                获取年
//getHours ()               获取小时
//getMinutes ()             获取分钟
//getSeconds ()             获取秒
//getMilliseconds ()        获取毫秒
//getTime ()                返回累计毫秒数(从1970/1/1午夜)
json对象

var str1 = ‘{“name”: “Alex”, “age”: 18}’; var obj1 = {“name”: “Alex”, “age”: 18};

// 对象转换成JSON字符串 var str = JSON.stringify(obj1); 注意Json需要大写

// JSON字符串转换成对象 var obj = JSON.parse(str1);

regexp 对象

RegExp 是正则表达式的缩写。

// 创建RegExp对象方式
var reg1 = new RegExp(“pattern”, [flags]);
pattern:正则表达式的文本

[flags]: 匹配模式,这个参数可选 该标志有以下值的任意组合
g :全局匹配;找到所有匹配,而不是在第一个匹配后停止
i :忽略大小写
m :多行; 将开始和结束字符(^和$)视为在多行上工作(也就是,分别匹配每一行的开始和结束(由 \n 或 \r 分割),而不只是只匹配整个输入字符串的最开始和最末尾处。
u: Unicode; 将模式视为Unicode序列点的序列.
y粘性匹配; 仅匹配目标字符串中此正则表达式的lastIndex属性指示的索引(并且不尝试从任何后续的索引匹配)。

RegExp 对象的方法
RegExp 对象有 3 个方法:
test():检索字符串中的指定值。返回值是 true 或 false。

1 var part2=new RegExp('e');
2 undefined
3 part2.test("The best things in life are free");
4 结果true

exec() :检索字符串中的指定值。返回值是被找到的值。如果没有发现匹配,则返回 null,检索字符串中指定的值。返回找到的值,并确定其位置。

var part2=new RegExp('e');
part2.exec("The best things in life are free");
结果;["e", index: 2, input: "The best things in life are free"]

RegExpObject.compile(regexp,modifier): 用于在脚本执行过程中编译正则表达式,也可用于改变和重新编译正则表达式。regexp 正则表达式。modifier规定匹配的类型。”g” 用于全局匹配,”i” 用于区分大小写,”gi” 用于全局区分大小写的匹配。

String对象与正则结合的4个方法

ar s2 = "hello world";

s2.match(/o/g);         // ["o", "o"]             查找字符串中 符合正则 的内容
s2.search(/h/g);        // 0                      查找字符串中符合正则表达式的内容位置
s2.split(/o/g);         // ["hell", " w", "rld"]  按照正则表达式对字符串进行切割
s2.replace(/o/g, "s");  // "hells wsrld"          对字符串按照正则进行替换

其中

s2.match(/o/g)下边式子的缩写,这样就不用新定义的对象了

var s2="hello, world";
var n = new RegExp("o","g");
console.log(s2.match(n ));
//RegExp对象

//创建正则对象方式1
// 参数1 正则表达式
// 参数2 验证模式:g(global)和i(忽略大小写)

// 用户名只能是英文字母、数字和_,并且首字母必须是英文字母。长度最短不能少于6位 最长不能超过12位。

// 创建RegExp对象方式
var reg1 = new RegExp("^[a-zA-Z][a-zA-Z0-9_]{5,11}$", "g");

// 匹配响应的字符串
var s1 = "bc123";

//RegExp对象的test方法,测试一个字符串是否符合对应的正则规则,返回值是true或false。
reg1.test(s1);  // true

// 创建方式2
// /填写正则表达式/匹配模式
var reg2 = /^[a-zA-Z][a-zA-Z0-9_]{5,11}$/g;

reg2.test(s1);  // true



// String对象与正则结合的4个方法
var s2 = "hello world";

s2.match(/o/g);         // ["o", "o"]             查找字符串中 符合正则 的内容
s2.search(/h/g);        // 0                      查找字符串中符合正则表达式的内容位置
s2.split(/o/g);         // ["hell", " w", "rld"]  按照正则表达式对字符串进行切割
s2.replace(/o/g, "s");  // "hells wsrld"          对字符串按照正则进行替换

// 关于匹配模式:g和i的简单示例
var s1 = "name:Alex age:18";

s1.replace(/a/, "哈哈哈");      // "n哈哈哈me:Alex age:18"
s1.replace(/a/g, "哈哈哈");     // "n哈哈哈me:Alex 哈哈哈ge:18"      全局匹配
s1.replace(/a/gi, "哈哈哈");    // "n哈哈哈me:哈哈哈lex 哈哈哈ge:18"  不区分大小写

RegExp对象

实例
在字符串中全局搜索 “man”,并用 “person” 替换。然后通过 compile() 方法,改变正则表达式,用 “person” 替换 “man”

var str='Every man in the world! Every woman on earth!';
patt=/man/g;
str2=str.replace(patt,"person");
console.log(str2);

结果:

"Every person in the world! Every woperson on earth!"
match对象
abs(x)      返回数的绝对值。
exp(x)      返回 e 的指数。
floor(x)    对数进行下舍入。
log(x)      返回数的自然对数(底为e)。
max(x,y)    返回 x 和 y 中的最高值。
min(x,y)    返回 x 和 y 中的最低值。
pow(x,y)    返回 x 的 y 次幂。
random()    返回 0 ~ 1 之间的随机数。
round(x)    把数四舍五入为最接近的整数。
sin(x)      返回数的正弦。
sqrt(x)     返回数的平方根。
tan(x)      返回角的正切。

Python的GUI编程(十七)Pack、Place、Grid

掩体阅读(39)

简介:

本文讲述如何使用 tkinter 的布局管理 (被称作 layout managers 或 geometry managers). tkinter 有三种布局管理方式:

· pack
· grid
· place

注意这三种布局管理在同一个 master window 里一定不可以混用! 布局管理有以下功能:

· 将控件放置在屏幕上,包括控件的位置及控件的大小
· 将控件注册到本地窗口系统中
· 管理控件在屏幕上的显示

虽然控件自己也可以指定大小和对齐方式等信息, 但最终的控件大小及位置还是由布局管理决定的.

Pack 布局管理

pack 是三种布局管理中最常用的. 另外两种布局需要精确指定控件具体的显示位置, 而 pack 布局可以指定相对位置, 精确的位置会由 pack 系统自动完成. 这也使得 pack 布局没有另外两种布局方式灵活. 所以 pack 是简单应用的首选布局

fill 控件填充方式
from Tkinter import *
root=Tk()
root1=Tk()
root.geometry('200x200')
# printroot.pack_slaves()
Label(root,text='pack').pack()
#使用用默认的设置pack将向下添加组件,第一个在最上方,然后是依次向下排列。
# 这样的话最后一个已经显示出来的,这就是为什么称Pack为弹性的容器的原因了,
# 虽然有这个特性,但它并不是总是能够按照我们的意思进行布局,我们可以强制设置容器的大小,以覆盖Pack的默认设置。Pack的优先级低。
for i in range(5):
    Label(root,text='pack'+str(i)).pack()
# printroot.pack_slaves()
#第一个只保证在Y方向填充,第二个保证在XY两个方向上填充,第三个不使用填充属性,
# 注意Pack只会吝啬地给出可以容纳这三个组件的最小区域,它不允许使用剩余的空间了,故下方留有“空白”。
Label(root,text ='pack5',bg = 'red').pack(fill = Y)
Label(root,text ='pack6',bg = 'blue').pack(fill = BOTH)
Label(root,text ='pack7',bg = 'green').pack(fill = X)

Label(root).pack()

# 创建三个Label分别使用不同的fill属性
Label(root1,text ='pack11',bg = 'red').pack(fill = Y,expand = 1)
Label(root1,text ='pack12',bg = 'blue').pack(fill = BOTH,expand = 1)
Label(root1,text ='pack13',bg = 'green').pack(fill = X,expand = 0)

# 创建三个Label分别使用不同的fill属性,改为水平放置
# 将第一个Label居左放置
Label(root1,text ='pack21',bg = 'red').pack(fill = Y,expand = 1,side = LEFT)
# 将第二个Label居右放置
Label(root1,text ='pack22',bg = 'blue').pack(fill = BOTH,expand = 1,side = RIGHT)
# 将第三个Label居左放置,靠Label放置,注意它不会放到Label1的左边
Label(root1,text ='pack23',bg = 'green').pack(fill = X,expand = 0,side = LEFT)

root.mainloop()
root1.mainloop()
设置组件之间的间隙大小

ipadx,ipady设置内部间隙
padx,pady设置外部间隙
side 顺次放置控件

from Tkinter import *
root=Tk()

# L1 =LabelFrame(root,text = 'pack1',bg = 'red').pack(side = LEFT,ipadx = 20)
Lb1=Label(root,text='Label1',bg='green')
Lb1.pack(side=LEFT,ipadx=20,expand=1)

Lb2=Label(root,text='Label2',bg='blue')
Lb2.pack(side=LEFT,padx=20,expand=1,fill=BOTH)

Lb3=Label(root,text='Label3',bg='red')
Lb3.pack(side=LEFT,pady=20,expand=0,fill=X)

root.mainloop()
Place 布局管理

Place 布局管理可以显式的指定控件的绝对位置或相对于其他控件的位置. 要使用 Place 布局, 调用相应控件的 place() 方法就可以了. 所有 tkinter 的标准控件都可以调用 place()
方法.

下面是一个使用 Place 布局的例子: 为 Label 控件设置随机的背景色, 然后计算各个 Label 的背景色的亮度(灰度值), 如果其亮度小于 120, 则将其前景色(文字颜色, fg属性)设置为白色, 否则设为黑色.

这样做是为了避免使背景色和前景色过于接近而导致文字不易阅读.

from Tkinter import *
root=Tk()
root.geometry('200x200')
lb=Label(root,text='Label',fg='red')
# 使用绝对坐标将组件放到指定的位置
lb.place(x=10,y=10,anchor=NW)

lb1=Label(root,text='Label2',fg='blue')
# 使用相对坐标放置组件位置
# relx,rely指定组件放置的绝对位置,范围为(0-1.0)
lb1.place(relx=0.5,rely=0.5,anchor=CENTER)

# place同时指定多个组件
# v = IntVar()
for i in range(1,6):
    Radiobutton(
        root,
        text = 'Radio' + str(i),
        # variable = v,
        #value = i
        ).place(y = 30* i,anchor = NW)

# 同时使用相对和绝对坐标时,相对坐标优先操作,然后是在这个相对坐标的基础上进行偏移
lb2 = Label(root,text= ' Place2',fg = 'green')
lb3 = Label(root,text= 'Place',fg = 'red')
# 先设置相对坐标为(0.01,0.2)
lb2.place(relx =0.01,rely = 0.2,anchor = CENTER,x = 160,y = 0)
# 先设置相对坐标为(0.01,0.02)
lb3.place(relx =0.01,rely = 0.02,anchor = CENTER,x = 160,y = 160)

root.mainloop()

Grid 布局管理

Pack 作为首选的布局管理方式,其运作方式并不是特别易于理解. 已经由 Pack 布局完成的设计也很难做出改变. Grid 布局在1996年作为另一种可供选择的布局方式被引入. Grid 布局方式易学易用, 但似乎大家还是习惯用 Pack.

Grid 在很多场景下是最好用的布局方式.相比而言, Pack 布局在控制细节方面有些力不从心. Place 布局虽然可以完全控制控件位置, 但这也导致使用 Place 会比其他两种布局方式更加复杂.

Grid 把控件位置作为一个二维表结构来维护,即按照行列的方式排列控件: 控件位置由其所在的行号和列号决定. 行号相同而列号不同的几个控件会被彼此上下排列; 列号相同而行号不同的几个控件会被彼此左右排列.

使用 Grid 布局的过程就是为各个控件指定行号和列号的过程. 不需要为每个格子指定大小, Grid 布局会自动设置一个合适的大小.

from Tkinter import *

colours = ['red', 'green', 'orange', 'white', 'yellow', 'blue']

r = 0
for c in colours:
    Label(text=c, relief=RIDGE, width=15).grid(row=r, column=0)
    Entry(bg=c, relief=SUNKEN, width=10).grid(row=r, column=1)
    r = r + 1

mainloop()  

Python的GUI编程(十五)Text(文本)

掩体阅读(50)

简介

Text 控件用来显示多行文本. Tkinter 的 Text 控件很强大, 很灵活, 可以实现很多功能. 虽然这个控件的主要用途是显示多行文本, 但其还可以被用作简单的文本编辑器, 甚至是网页浏览器. 

Text 控件可以显示网页链接, 图片, HTML页面, 甚至 CSS 样式表. 

from Tkinter import *
root=Tk()

text=Text(root,width=100,height=3,fg='red')
# insert的第一个参数为索引;第二个为添加的内容
text.insert(1.0,'fgjsdfkjgierjgidfkgjol ')
# 
text.insert(1.0,'uilqwwwwwre ')
# 
text.insert('2.end','\n')
text.insert(2.0,'weqrfrfrfrfrfrfrfrf ')
text.insert(2.0,'qwrewrrrrrw ')
# text.insert(3,'fgjsdfkjgierjgidfkgjol')
text.pack()
root.mainloop()

mark是用来表示在Text中位置的一类符号
mark: INSERT/CURRENT/END/SEL_FIRST/SEL_LAST控制添加位置

from Tkinter import *
root = Tk()
t = Text(root)
#向Text中添加10行文本
for i in range(1,10):
    t.insert(1.0,'❤❤❤❤❤❤❤❤\n')
#定义各个Button的回调函数,这些函数使用了内置的 mark:INSERT/CURRENT/END/SEL_FIRST/SEL_LAST
def insertText():
    t.insert(INSERT,' Love❤')
def currentText():
    t.insert(CURRENT,' Love❤')
def endText():
    t.insert(END,' Love❤')
def selFirstText():
    t.insert(SEL_FIRST,' Love❤')
def selLastText():
    t.insert(SEL_LAST,' Love❤')
#INSERT
Button(root,
       text = 'insert Love❤ at INSERT',
       command = insertText
       ).pack(fill = X)
#CURRENT
Button(root,
       text = 'insert Love❤ at CURRENT',
       command = insertText
       ).pack(fill = X)
#END
Button(root,
       text = 'insert Love❤ at END',
       command = endText
       ).pack(fill = X)
#SEL_FIRST
Button(root,
       text = 'insert Love❤ at SEL_FIRST',
       command = selFirstText
       ).pack(fill = X)
#SEL_LAST
Button(root,
       text = 'insert Love❤  at SEL_LAST',
       command = selLastText
       ).pack(fill = X)

t.pack()
root.mainloop()
#几个内置的mark:
#INSERT:光标的插入点
#CURRENT:鼠标的当前位置所对应的字符位置
#END:这个Text buffer的最后一个字符
#SEL_FIRST:选中文本域的第一个字符,如果没有选中区域则会引发异常
#SEL_LAST:选中文本域的最后一个字符,如果没有选中区域则会引发 异常

使用表达式来增强mark
表达式(expression)可以个性任何的Indexes
– count chars :前移count字符
– count chars : 后移count字符
– count lines : 前移count行
– count lines : 后移count行
– linestart: 移动到行的开始
– linesend: 移动到行的结束
– wordstart:移动到字的开始
– wordend:移动到字的结束

from Tkinter import *
root = Tk()
t = Text()
# 向第一行,第一列添加文本0123456789
for i in range(1,10):
    t.insert(1.0,'0123456789\n')
a = 'test_mark'
def forwardChars():
    # 直接连接字符串
    t.mark_set(a,CURRENT + '+ 5 chars')
    # t.mark_set(a,CURRENT + '+5c')
def backwardChars():
    # t.mark_set(a,CURRENT + '- 5 chars')
    t.mark_set(a,CURRENT + '-5c')
def forwardLines():
    # t.mark_set(a,CURRENT + '+ 5 lines)
    t.mark_set(a,CURRENT + '+5l')
def backwardLines():
    # t.mark_set(a,CURRENT + '- 5 lines)
    t.mark_set(a,CURRENT + '-5l')
def lineStart():
    # 注意linestart前面的那个空格不可省略
    t.mark_set(a,CURRENT + ' linestart')
def lineEnd():
    # 注意lineend前面的那个空格不可省略
    t.mark_set(a,CURRENT + ' lineend')
def wordStart():
    # 移动到当前字的开始。
    t.mark_set(a,CURRENT + ' wordstart')
def wordend():
    # 移动到当前字的结束
    t.mark_set(a,CURRENT + ' wordend')
# mark:test_mark默认值为CURRENT
t.mark_set(a,CURRENT)
Button(root,text = 'forward 5 chars',command = forwardChars).pack(fill = X)
Button(root,text = 'backward 5 chars',command = backwardChars).pack(fill = X)
Button(root,text = 'forward 5 lines',command = forwardLines).pack(fill = X)
Button(root,text = 'backward 5 lines',command = backwardLines).pack(fill = X)
Button(root,text = 'line start',command = lineStart).pack(fill = X)
Button(root,text = 'line end',command = lineEnd).pack(fill = X)
Button(root,text = 'word start',command = lineEnd).pack(fill = X)
Button(root,text = 'word end',command = lineEnd).pack(fill = X)
# 测试三个位置的不同,CURRENT可以得知是当前光标的位置;mark就表示mark的位置了,INSERT好像一植都在1.0处没有改变。
def insertText():
    t.insert(INSERT,'insert')
def currentText():
    t.insert(CURRENT,'current')
def markText():
    t.insert(a,'mark')
Button(root,text = 'insert jcodeer.cublog.cn',command = insertText).pack(fill = X)
Button(root,text = 'current jcodeer.cublog.cn',command = currentText).pack(fill = X)
Button(root,text = 'mark jcodeer.cublog.cn',command = markText).pack(fill = X)
t.pack()
root.mainloop()

滑动条移动读取文本:

from Tkinter import *
root=Tk()
S=Scrollbar(root)
T=Text(root,height=5,width=50)
S.pack(side=RIGHT,fill=Y)
T.pack(side=LEFT,fill=Y)
S.config(command=T.yview)
T.config(yscrollcommand=S.set)
quote='T ext widg ets provide advanced capabilities that allow you to edit a multiline text and format the way it has to be displayed, such as chang ing its color and font.\
You can also use eleg ant structures like tabs and marks to locate specific sections of the text, and apply chang es\
to those areas. Moreover, you can embed windows and imag es in the text because this widg et was desig ned to\
handle both plain and formatted text.'
T.insert(END,quote)
mainloop()
from Tkinter import *
root=Tk()

text1=Text(root,height=20,width=30)
photo=PhotoImage(file='D:/temp/1.gif')
text1.insert(END,'\n')
text1.image_create(END,image=photo)

text1.pack(side=LEFT)

text2=Text(root,height=20,width=50)
scroll=Scrollbar(root,command=text2.yview)
text2.tag_config('bold_italics',font=('Arial',12,'bold','italic'))
text2.tag_config('big',font=('Verdana',20,'bold'))
text2.tag_config('color',foreground='#476042',font=('Tempus Sans ITC',12,'bold'))
text2.tag_bind('follow','<1>',lambda  e,t=text2:t.insert(END,'NO Pass'))
text2.insert(END,'\n Flower\n','big')
quto='池中荷花'
text2.insert(END,quto,'color')
text2.insert(END,'follow-up\n','follow')
text2.pack(side=LEFT)
scroll.pack(side=RIGHT,fill=Y)

root.mainloop()

tag _config:您可以使用此方法来配置标记属性,其中包括:对齐(中心、左或右)、选项卡(此属性与文本小部件选项卡的属性具有相同的功能)和下划线(用于下划线标记的文本)。

Python的GUI编程(二)Label(标签)

掩体阅读(49)

上节讲完的GUI的主要控件
Label控件:Label 控件用以显示文字和图片. Label 通常被用来展示信息, 而非与用户交互.
class Label(Widget):Label类继承Widget类
Label widget which can display text and bitmaps.

控件标签能够显示文本和图片

类的初始化函数(构造函数)
def __init__(self, master=None, cnf={}, **kw):

第一个是self,即类对象本身。
第二个是master,在Tkinter中,一个控件可能属于另一个控件,这时另一个控件就是这个控件的master。默认一个窗口没有master,因此master有None的默认值。
第三个cnf不了解
第四个是kw为命名关键字参数,

Construct a label widget with the parent MASTER.
STANDARD OPTIONS:
标准选项(属性)

activebackground, activeforeground, anchor,
background, bitmap, borderwidth, cursor,
disabledforeground, font, foreground,
highlightbackground, highlightcolor,
highlightthickness, image, justify,
padx, pady, relief, takefocus, text,
textvariable, underline, wraplength

WIDGET-SPECIFIC OPTIONS height, state, width “””

调用BaseWidget中的初始化函数
Widget.__init__(self, master, 'label', cnf, kw)

class Widget(BaseWidget, Pack, Place, Grid):Widget类继承BaseWidget, Pack, Place, Grid类
Internal class.

Base class for a widget which can be positioned with the geometry managers
Pack, Place or Grid.
小部件的基类,它可以定位于几何管理器。包、位置或网格。
pass

1、背景自定义

背景,有三部分构成:内容区+填充区+边框

<1>内容区参数有:width,length用于指定区域大小,如果显示前景内容是文本,则以单个字符大小为单位;如果显示的是图像,则以像素为单位。默认值是根据具体显示的内容动态调整。类型是int。
background用于指定背景的颜色,默认值根据系统而定。

<2>填充区参数:指的是内容区和边框之间的间隔大小,单位是像素。参数有:padx , pady,类型是int。

<3>边框参数:样式relief(可选值为:flat(默认),sunken,raised,groove,ridge),borderwidth(边框的宽度,单位是像素,默认根据系统而定,一般是1或2像素)

highlightbackground,highlightcolor,highlightthickness 三个边框参数仅在Label允许接收焦点的情况下(tackfocus=True),用于设置焦点获取前后高亮边框颜色以及高亮边框宽度。

2、前景自定义

前景定义分为文本内容和图像两小块来说明。

2.1文本

文本内容选项有:

<1>指定字体和字体大小,如:font = (font_name,size),默认有系统指定。

<2>文本对齐方式,justify = “center(默认)left/right/”

<3>指定文本(或图像)颜色,foreground = “指定的颜色”,可以是英文名字,也可以是RGB格式的

<4>指定文本内容:(静态的)text = “目标字符串…..”;  (动态更新的)textvariable = str_obj,当str_obg的内容改变时,会更新Label中对应内容。

这里需要注意的是str_obj必须是TKinter所支持的字符串类型变量,如:str_obj = Tkinter.StringVar()      str_obj.set(“目标文本内容”)

<5>单个字符添加下划线,underline = index, index是目标字符串中的字符索引值。

<6>文本或图像在背景内容区的位置:anchor  可选值为(n,s,w,e,ne,nw,sw,se,center)eswn是东南西北英文的首字母

2.2图像

图像内容选项有:

<1>指定图片:bitmap = bitmap_image,当指定image选项的时候,这个参数会被忽略掉     或者  image = normal_image(仅支持GIF, PPM/PGM格式的图片)” 。

需要注意的是这里的所用到的图片对象bitmap_image  normal_image都是需要经过TKinter转换后的图像格式。

如: bitmap_image = TKinter.BitmapImage(file = “位图片路径”)

normal_image = TKinter.PhotoImage(file = “gif 、ppm/pgm图片路径”)

图片和文本取舍:compound参数可以控制要显示的文本和图像。当同时指明了要显示的文本和图像时,可以通过该参数来进行不同设置。

可选值:None 默认值,表示只显示图像,不显示文本;bottom/top/left/right,表示图片显示在文本的下/上/左/右;center,表示文本显示在图片中心上方。

3、Label的其他参数

<1>activebacakground  activeforground   用于设置Label处于活动(active)状态下的背景和前景颜色,默认由系统指定。

<2>diableforground  指定当Label不可用的状态(Disable)下的前景颜色,默认由系统指定。

<3>cursor 指定鼠标经过Label的时候,鼠标的样式,默认由系统指定。

<4>state  指定Label的状态,用于控制Label如何显示。可选值有:normal(默认)/active/disable。

参考:http://www.cnblogs.com/zyq-blog/p/5712926.html

属性用法:
fg(foreground):前景色
bg(background):背景色
设置背景色的一个大的用处是:可以判断控件的大小(不同的控件使用不同的颜色。

width:    宽度一个汉字约为2个单位
height:    高度    与默认的汉字高度约一致
指文本所在区域,文本默认区域居中

from Tkinter import *
root=Tk()
Lab1=Label(root,bg='red',text='床前明月光').pack()
Lab2=Label(root,bg='Green',text='疑是地上霜').pack()
Lab3=Label(root,bg='Yellow',text='举头望明月').pack()
Lab11=Label(root,bg='red',text='床前明月光',width=16,height=6).pack()
Lab22=Label(root,bg='Green',text='疑是地上霜',width=18,height=8).pack()
Lab33=Label(root,bg='Yellow',text='举头望明月',width=12,height=12).pack()
root.mainloop()

compound:    指定文本(text)与图像(bitmap/image)是如何在Label上显示,缺省为None,当指定image/bitmap时,文本(text)将被覆盖,只显示图像了。

left:    图像居左
right:    图像居右
top:    图像居上
bottom:图像居下
center:文字覆盖在图像上
bitmap/image:
显示在Label上的图像
text:
显示在Label上的文本

from Tkinter import *

#创建界面窗口
Win=Tk()
#只能显示GIF格式的图片
img=PhotoImage(file="D:/temp/1.gif")
#Label是个类,对其初始化
# #pack属性将空间加载到窗口上
#文本内容显示窗口
lab1=Label(Win,text="Hello World!",fg='red',image=img,bg='green',compound='right').pack()
lab2=Label(Win,text="Hello World!",fg='black',image=img,bg='red',compound='left').pack()
lab3=Label(Win,text="Hello World!",fg='red',image=img,bg='blue',compound='center').pack()
# 启动 Tkinter 的消息循环 (event loop)
Win.mainloop()

wraplength:    指定多少单位后开始换行(经测试默认字体情况下,一个汉字或中文标点的长度大约wraplength=12单位,一个英文字符(字母,标点等)占6~9个单位,不清楚为什么没有规律)根据文本中的字符占位,设置wraplength个单位后,字符换行

justify:        指定多行的对齐方式,必须是 left, right, or center

ahchor:        指定文本(text)或图像(bitmap/image)在Label中的显示位置(方位)

可用的值:
e、w、n、s、ne、se、sw、sn、center
布局如下图:类似空间平面中的8个方位

nw(左上)        n (中上)      ne(右上)
w  (左中)   center(中间)   e(右中)
sw(左下)        s (中下)      se(右下)

from Tkinter import *

root=Tk()
#每行显示一句:每句5个汉字加一个中文标点符号(英文为6)warplength=5*12+12
Lab1=Label(root,bg='red',text='床前明月光,疑是地上霜,举头望明月,低头思故乡。',width=24,height=4,wraplength=72,justify='left').pack()
#height与默认的汉字高度约一致,一个汉字约为2个单位的width
Lab2=Label(root,bg='Green',text='疑是地上霜',width=18,height=5,wraplength=12,anchor='nw').pack()
Lab3=Label(root,bg='Yellow',text='举头望明月',width=18,height=2,anchor='ne',justify='right').pack()
root.mainloop()

justify与anchor的区别了:一个用于控制多行的对齐;另一个用于控制整个文本块在Label中的位置

边界框的使用。

from Tkinter import *
root=Tk()
img=PhotoImage(file='D:/temp/1.gif')
Lab1=Label(root,
bg='blue',
text='床前明月光,疑是地上霜,举头望明月,低头思故乡。',
fg='purple',
relief="groove",
# 中心框主要是显示窗口内容(文字、图片)
width=360,
height=360,
wraplength=72,
justify='left',
anchor = "s",
# padx/pady次边框(内容边界加宽)
padx=10,
pady=10,
# 外层框与窗口连接的(边界修饰)
borderwidth=20,
#图像显示在底部
image=img,
compound='bottom').pack()
root.mainloop()

使用PhotoImage和BitmapImage显示bmp或gif文件

示例:

from Tkinter import *
#创建界面窗口
Win=Tk()
#只能显示GIF格式的图片
img=PhotoImage(file="D:/temp/1.gif")
#Label是个类,对其初始化
# #pack方法将空间加载到窗口上
#图片显示在窗口左边
lab1=Label(Win,image=img).pack(side='left')
#文本内容显示窗口右边,字体颜色为红色
lab2=Label(Win,text="Hello World!",font=6,fg='red',padx=100,pady=100).pack(side='right')
# 启动 Tkinter 的消息循环 (event loop)
Win.mainloop()

Label窗口部件上调用了pack方法,它告诉Label窗口部件去调整自己的尺寸来适应所给定文本的大小,并且使用自己可见。

mainloop()方法作用:将一直处在事件循环之中,直到我们关闭了这个窗口。事件循环不仅仅处理来自用户的事件(如鼠标敲击和按键按下)或者窗口系统(重绘事件和窗口配置消 息),它也处理来自Tkinter自身的工作等待队列,这些工作之一就包括由pack方法所产生的工作和显示更新。

这就意味着这个应用程序窗口在进入这个 事件循环之前将不会显示出来。

Pack:pack几何管理器通过在一个帧中把窗口部件包装到一个父部件中来创建一个版面。为了对窗口部件使用这个几何管理器,我们在这个窗口部件上使用pack方法。

Python文件操作——主要函数

掩体阅读(46)

Python常见文件操作示例

os.path 模块中的路径名访问函数
分隔

basename() 去掉目录路径, 返回文件名
dirname() 去掉文件名, 返回目录路径
join() 将分离的各部分组合成一个路径名
split() 返回 (dirname(), basename()) 元组
splitdrive() 返回 (drivename, pathname) 元组
splitext() 返回 (filename, extension) 元组

信息

getatime() 返回最近访问时间
getctime() 返回文件创建时间
getmtime() 返回最近文件修改时间
getsize() 返回文件大小(以字节为单位)

查询

exists() 指定路径(文件或目录)是否存在
isabs() 指定路径是否为绝对路径
isdir() 指定路径是否存在且为一个目录
isfile() 指定路径是否存在且为一个文件
islink() 指定路径是否存在且为一个符号链接
ismount() 指定路径是否存在且为一个挂载点
samefile() 两个路径名是否指向同个文件

os模块中的文件操作:

os 模块属性

os.path.isdir(name):判断name是不是一个目录,name不是目录就返回false
os.path.isfile(name):判断name是不是一个文件,不存在name也返回false
os.path.exists(name):判断是否存在文件或目录name
os.path.getsize(name):获得文件大小,如果name是目录返回0L
os.path.abspath(name):获得绝对路径
os.path.normpath(path):规范path字符串形式
os.path.split(name):分割文件名与目录(事实上,如果你完全使用目录,它也会将最后一个目录作为文件名而分离,同时它不会判断文件或目录是否存在)
os.path.splitext():分离文件名与扩展名
os.path.join(path,name):连接目录与文件名或目录
os.path.basename(path):返回文件名
os.path.dirname(path):返回文件路径

linesep 用于在文件中分隔行的字符串
sep 用来分隔文件路径名的字符串
pathsep 用于分隔文件路径的字符串
curdir 当前工作目录的字符串名称
pardir (当前工作目录的)父目录字符串名称
“`
1.重命名:os.rename(old, new)

2.删除:os.remove(file)

3.列出目录下的文件:os.listdir(path)

4.获取当前工作目录:os.getcwd()

5.改变工作目录:os.chdir(newdir)

6.创建多级目录:os.makedirs(r”c:\python\test”)

7.创建单个目录:os.mkdir(“test”)

8.删除多个目录:os.removedirs(r”c:\python”) #删除所给路径最后一个目录下所有空目录。

9.删除单个目录:os.rmdir(“test”)

10.获取文件属性:os.stat(file)

11.修改文件权限与时间戳:os.chmod(file)

12.执行操作系统命令:os.system(“dir”)

13.启动新进程:os.exec(), os.execvp()

14.在后台执行程序:osspawnv()

15.终止当前进程:os.exit(), os._exit()

16.分离文件名:os.path.split(r”c:\python\hello.py”) –> (“c:\python”, “hello.py”)

17.分离扩展名:os.path.splitext(r”c:\python\hello.py”) –> (“c:\python\hello”, “.py”)

18.获取路径名:os.path.dirname(r”c:\python\hello.py”) –> “c:\python”

19.获取文件名:os.path.basename(r”r:\python\hello.py”) –> “hello.py”

20.判断文件是否存在:os.path.exists(r”c:\python\hello.py”) –> True

21.判断是否是绝对路径:os.path.isabs(r”.\python\”) –> False

22.判断是否是目录:os.path.isdir(r”c:\python”) –> True

23.判断是否是文件:os.path.isfile(r”c:\python\hello.py”) –> True

24.判断是否是链接文件:os.path.islink(r”c:\python\hello.py”) –> False

25.获取文件大小:os.path.getsize(filename)

26.*******:os.ismount(“c:\”) –> True

27.搜索目录下的所有文件:os.path.walk()

“`

shutil模块对文件的操作:

1.复制单个文件:shultil.copy(oldfile, newfle)
2.复制整个目录树:shultil.copytree(r”.\setup”, r”.\backup”)
3.删除整个目录树:shultil.rmtree(r”.\backup”)

临时文件的操作:

1.创建一个唯一的临时文件:tempfile.mktemp() –> filename
2.打开临时文件:tempfile.TemporaryFile()

内存文件(StringIO和cStringIO)操作
[4.StringIO] #cStringIO是StringIO模块的快速实现模块

1.创建内存文件并写入初始数据:f = StringIO.StringIO(“Hello world!”)
2.读入内存文件数据:print f.read() #或print f.getvalue() –> Hello world!
3.想内存文件写入数据:f.write(“Good day!”)
4.关闭内存文件:f.close()

import os
import os.path
import unittest
import time
#import pygame

class PyFileCommonOperatorTest(unittest.TestCase):
    def __init__(self):
        """constructor"""

   def test01(self):
        print os.linesep
        print os.sep
        print os.pathsep
        print os.curdir
        print os.pardir
        print os.getcwd()
        print 'unittest here'


if __name__ == "__main__":
    t = PyFileCommonOperatorTest()

Python异常处理——自定义异常

掩体阅读(60)

有时候python自带异常不够用,如同java,python也可以自定义异常,并且可以手动抛出。注意,自定义异常只能由自己抛出。python解释器是不知道用户自定义异常是什么鬼的。

raise语句

主动抛出异常。
格式:
主动抛出异常终止程序
raise 异常名称(‘异常描述’)

raise RuntimeError('testError')

主动抛出这个异常,并加以解释。

自定义异常

python的异常分为两种.
1、内建异常,就是python自己定义的异常。
2、不够用,用户自定义异常,
首先看看python的异常继承树

我们可以看到python的异常有个大基类。然后继承的是Exception。所以我们自定义类也必须继承Exception。

#最简单的自定义异常
class FError(Exception):
    pass

抛出异常、用try-except抛出

try:
    raise FError("自定义异常")
except FError as e:
    print(e)

在这里给一个简单的自定义异常类模版。

class CustomError(Exception):
    def __init__(self,ErrorInfo):
        super().__init__(self) #初始化父类
        self.errorinfo=ErrorInfo
    def __str__(self):
        return self.errorinfo

if __name__ == '__main__':
    try:
        raise CustomError('客户异常')
    except CustomError as e:
        print(e)

Use these ideas being a manual, but don’t forget that you just must not fit all this in to a review that is solitary that will produce for a significant extended review!

站点默认阅读(40)

You are going to discover that even beyond faculty, you are going to have that all-normal impulse to spend some time writing. In college, I Would prize myself after a very long nights studying by using time to study several chapters from a popular story. Yes, there exists a last deadline, but you actually need to present your entries representatives a superb head start on reading your entries article. (更多…)

python面向对象——继承和多态

掩体阅读(47)

上一节讲了封装

这节继续讲面向对象编程三大特性中其他两类:继承和多态

继承(分:单继承,多继承)
1 class Dad:
 2     money=10000
 3     def __init__(self,name):
 4         print('baba')
 5         self.name=name
 6     def hit_son(self):
 7         print('%s 我要有钱' %self.name)
 8 
 9 class Son(Dad):
10     pass
11 
12 s1=Son('zy')
13 print(s1.money)
14 print(s1.__dict__)
15 
16 结果:
17 #baba
18 #10000
19 #{'name': 'zy'}

什么时候该用封装?

1.当类之间有显著不同,且较小的类是较大类所需的组件时,用组合比较好。

2.当类之间有很多相同的功能,提取这些共同的功能做成基类,用继承比较好。

继承有两种含义

含义一:继承基类的方法,并且做出自己的改变或者扩展(代码可以重用)

含义二:声明某个子类兼容于某个基类,定义一个接口类,子类继承接口类,并且实现接口中定义的方法。

继承顺序:深度优先,广度优先

(当时经典类时,多继承情况下,会按照深度优先的方法查找。当时新式类时,会按照广度优先的方式查找。)

在OOP(Object Oriented Programming)程序设计中,当我们定义一个class的时候,可以从某个现有的class 继承,新的class称为子类(Subclass),而被继承的class称为基类、父类或超类(Base class、Super class)。

我们先来定义一个class Person,表示人,定义属性变量 name 及 sex (姓名和性别);

定义一个方法print_title():当sex是male时,print man;当sex 是female时,print woman。参考如下代码:

1 class Person(object):
 2     def __init__(self,name,sex):
 3         self.name = name
 4         self.sex = sex
 5         
 6     def print_title(self):
 7         if self.sex == "male":
 8             print("man")
 9         elif self.sex == "female":
10             print("woman")
11 
12 class Child(Person):                            # Child 继承 Person
13     pass
14             
15 May = Child("May","female")
16 Peter = Person("Peter","male")
17 
18 print(May.name,May.sex,Peter.name,Peter.sex)    # 子类继承父类方法及属性
19 May.print_title()
20 Peter.print_title()

而我们编写 Child 类,完全可以继承 Person 类(Child 就是 Person);使用 class subclass_name(baseclass_name) 来表示继承;

继承有什么好处?最大的好处是子类获得了父类的全部属性及功能。如下 Child 类就可以直接使用父类的 print_title() 方法

实例化Child的时候,子类继承了父类的构造函数,就需要提供父类Person要求的两个属性变量 name 及 sex:

在继承关系中,如果一个实例的数据类型是某个子类,那它也可以被看做是父类(May 既是 Child 又是 Person)。但是,反过来就不行(Peter 仅是 Person,而不是Child)。

继承还可以一级一级地继承下来,就好比从爷爷到爸爸、再到儿子这样的关系。而任何类,最终都可以追溯到根类object,这些继承关系看上去就像一颗倒着的树。比如如下的继承树:

[]

isinstance() 及 issubclass()
Python 与其他语言不同点在于,当我们定义一个 class 的时候,我们实际上就定义了一种数据类型。我们定义的数据类型和Python自带的数据类型,比如str、list、dict没什么两样。

Python 有两个判断继承的函数:isinstance() 用于检查实例类型;issubclass() 用于检查类继承。参见下方示例:

class Person(object):
    pass

class Child(Person):                 # Child 继承 Person
    pass

May = Child()
Peter = Person()    

print(isinstance(May,Child))         # True
print(isinstance(May,Person))        # True
print(isinstance(Peter,Child))       # False
print(isinstance(Peter,Person))      # True
print(issubclass(Child,Person))      # True

多态

多态的概念指出了对象如何通过他们共同的属性和动作来操作及访问,而不需要考虑他们具体的类。执行过程中才显示出多态。

1 class Person(object):
 2     def __init__(self,name,sex):
 3         self.name = name
 4         self.sex = sex
 5         
 6     def print_title(self):
 7         if self.sex == "male":
 8             print("man")
 9         elif self.sex == "female":
10             print("woman")
11 
12 class Child(Person):                # Child 继承 Person
13     def print_title(self):
14         if self.sex == "male":
15             print("boy")
16         elif self.sex == "female":
17             print("girl")
18         
19 May = Child("May","female")
20 Peter = Person("Peter","male")
21 
22 print(May.name,May.sex,Peter.name,Peter.sex)
23 May.print_title()
24 Peter.print_title()

当子类和父类都存在相同的 print_title()方法时,子类的 print_title() 覆盖了父类的 print_title(),在代码运行时,会调用子类的 print_title()

多态的好处就是,当我们需要传入更多的子类,例如新增 Teenagers、Grownups 等时,我们只需要继承 Person 类型就可以了,而print_title()方法既可以直不重写(即使用Person的),也可以重写一个特有的。这就是多态的意思。

调用方只管调用,不管细节,而当我们新增一种Person的子类时,只要确保新方法编写正确,而不用管原来的代码。这就是著名的“开闭”原则:

对扩展开放(Open for extension):允许子类重写方法函数

对修改封闭(Closed for modification):不重写,直接继承父类方法函数

子类重写构造函数

子类可以没有构造函数,表示同父类构造一致;子类也可重写构造函数;现在,我们需要在子类 Child 中新增两个属性变量:mother 和 father,我们可以构造如下(建议子类调用父类的构造方法,参见后续代码):

1 class Person(object):
 2     def __init__(self,name,sex):
 3     self.name = name
 4     self.sex = sex
 5 
 6 class Child(Person):                # Child 继承 Person
 7     def __init__(self,name,sex,mother,father):
 8         self.name = name
 9         self.sex = sex
10         self.mother = mother
11         self.father = father
12 
13 May = Child("May","female","April","June")
14 print(May.name,May.sex,May.mother,May.father) 

若父类构造函数包含很多属性,子类仅需新增1、2个,会有不少冗余的代码,这边,子类可对父类的构造方法进行调用,参考如下:


1 class Person(object): 2 def __init__(self,name,sex): 3 self.name = name 4 self.sex = sex 5 6 class Child(Person): # Child 继承 Person 7 def __init__(self,name,sex,mother,father): 8 Person.__init__(self,name,sex) # 子类对父类的构造方法的调用 9 self.mother = mother 10 self.father = father 11 12 May = Child("May","female","April","June") 13 print(May.name,May.sex,May.mother,May.father)
多重继承

多重继承的概念应该比较好理解,比如现在需要新建一个类 baby 继承 Child , 可继承父类及父类上层类的属性及方法,优先使用层类近的方法,代码参考如下:

1 class Person(object):
 2     def __init__(self,name,sex):
 3         self.name = name
 4         self.sex = sex
 5         
 6     def print_title(self):
 7         if self.sex == "male":
 8             print("man")
 9         elif self.sex == "female":
10             print("woman")
11             
12 class Child(Person):
13     pass
14 
15 class Baby(Child):
16     pass
17 
18 May = Baby("May","female")        # 继承上上层父类的属性
19 print(May.name,May.sex)            
20 May.print_title()                 # 可使用上上层父类的方法
21 
22 
23 class Child(Person):                
24     def print_title(self):
25         if self.sex == "male":
26             print("boy")
27         elif self.sex == "female":
28             print("girl")
29             
30 class Baby(Child):
31     pass
32             
33 May = Baby("May","female")
34 May.print_title()                # 优先使用上层类的方法

好的,到这里面向对象编程三大特性都讲完了,希望对你能有帮助!!

记得转发和点赞哦QQ·

Python编程-字符串列表

掩体阅读(75)

一、字符串的常见操作:

1.find:
变量名.find(‘关键词’) 即在字符串中找对应的关键字,返回一个对应位置下标,若找不到,返回’-1′,找到第一个关键词后就返回可以用。

rfind 来从右边开始寻找,如fileName.rfind(‘.’)

2.index:
用法与find一致,找不到时返回一个异常信息。

3.count:
变量名.count(‘关键词’,起始位置,结束位置) 即在起始位置与结束位置间寻找关键词,并返回一个统计数量。

4.replace:
变量名.replace(‘目标词’,’替换词’,替换次数) 即用替换词 替代目标词,默认替换全部目标词。

5.split:
变量名.split(‘目标词’) 删除目标词并将字符串从目标词处切割开,返回一个列表。

6.capitalize
把第一个字符变为大写

7.startswith/endswith
判断是否以关键词开头/结尾,返回一个布尔值

8.lower/upper
转换所有大写字符为小写字符/转换所有小写字符为大写

9.ljust/rjust/center
如:变量名.center(目标长度) 靠左/靠右/中间 对齐

10.strip/lstrip/rstrip
删除字符串前后/左边/右边 的空格

11.partition/rpartition
以关键词为中心,分为几个部分,与split类似,但不删除目标词,返回一个tuple

12.splitlines
从换行符处进行分割,返回一个包含各行作为元素的列表

13.isalpha/isdigit/alnum
判断是否为字母/数字/字母或数字 返回一个布尔值

14.isspace
判断是否只包含空格

15.join
链接作用,与+ 作用类似如: c = ‘=’

name = ['aaa','bbb','ccc']
c.join(name)
>>>'aaa=bbb=ccc'
二、对列表进行的操作
names = ['xiaohong','xiaoming','laowang']
test = ['aaa','bbb']

#将列表作为一个元素加入到原列表中

names.append(‘xiaogang’)
names.append(test)

#插入一个元素

names.insert(1,’xiaoxiao’)

#将列表延长到原列表中

name.extend(test)

#修改某一个元素:

names[1] = ‘mingming’

#计数与查找

name = [‘aa’,’bb’,’cc’]
name.count(‘aa’)
name.index(‘aa’)
name.index(‘bb’)

#删除元素

del: 根据下标进行删除
pop: 删除最后一个元素
remove: 根据元素的值进行删除

#列表嵌套
#demo七个老师随进进入3个教室

import random

office = [[],[],[]]
list = ['A','B','C','D','E','F','G']
   for name in list:
    i = random.randint(0,2)
    office[i].append(name)

    i = 1
    for house in office:
      print('第%d个教室的人数是:%d'% (i,len(house)))
      for name in house:
        print(name,end = ' ')
      print()
      print('='*30)
    i += 1

计算机基础:计算机组成

掩体阅读(379)

计算机组成的任务是在指令集系统结构确定分配给硬件系统的功能和概念结构之后,研究各组成部分的内部构造和相互联系,以实现机器指令集的各种功能和特性。这种联系包括各功能部件的内部和相互作用计算机组成的任务是在指令集系统结构确定分配给硬件系统的功能和概念结构之后,研究各组成部分的内部构造和相互联系,以实现机器指令集的各种功能和特性。这种联系包括各功能部件的内部和相互作用。

计算机组成的任务是在指令集系统结构确定分配给硬件系统的功能和概念结构之后,研究各组成部分的内部构造和相互联系,以实现机器指令集的各种功能和特性。这种联系包括各功能部件的内部和相互作用。

计算机组成要解决的问题是在所希望达到的性能和价格下,怎样最佳,最合理地把各个数倍和部件组成成计算机,已实现所确定的ISA。计算机组成设计要确定的方面应包括:## # # 计算机组成要解决的问题是在所希望达到的性能和价格下,怎样最佳,最合理地把各个数倍和部件组成成计算机,已实现所确定的ISA。

计算机组成设计要确定的方面应包括:

(1)数据通路宽度:数据总线上一次并行传送的信息位数。
(2)专用部件的设置:是否设置乘除法、浮点运算、字符处理、地址运算等专用部件,设置的数量与机器要达到的速度、价格及专用部件的使用频度等有关。
(3)各种操作对部件的共享程度:分时共享使用程度高,虽限制了速度,但价格便宜。设置部件多降低共享程度,因操作并行度提高,可提高速度,但价格也会提高。
(4)功能部件的并行度:是用顺序串行,还是用重叠、流水或分布式控制和处理。
(5)控制机构的组成方式:用硬联还是微程序控制,是单机处理还是多机或功能分布处理。
(6)缓冲和排队技术:部件间如何设置及设置多大容量的缓冲器来协调它们的速度差;用随机、先进先出、先进后出、优先级,还是循环方式来安排事件处理的顺序。
(7)预估、预判技术:为优化性能用什么原则预测未来行为。
(8)可靠性技术:用什么冗余和容错技术来提高可靠性。

硬件组成部分编辑主要分为五个部分:

  1. 控制器(Control):是整个计算机的中枢神经,其功能是对程序规定的控制信息进行解释,根据其要求进行控制,调度程序、数据、地址,协调计算机各部分工作及内存与外设的访问等。
  2. 运算器(Datapath):运算器的功能是对数据进行各种算术运算和逻辑运算,即对数据进行加工处理。
  3. 存储器(Memory):存储器的功能是存储程序、数据和各种信号、命令等信息,并在需要时提供这些信息。
  4. 输入(Input system):输入设备是计算机的重要组成部分,输入设备与输出设备合称为外部设备,简称外设,输入设备的作用是将程序、原始数据、文字、字符、控制命令或现场采集的数据等信息输入到计算机。常见的输入设备有键盘、鼠标器、光电输入机、磁带机、磁盘机、光盘机等。
  5. 输出(Output system):输出设备与输入设备同样是计算机的重要组成部分,它把计算机的中间结果或最后结果、机内的各种数据符号及文字或各种控制信号等信息输出出来。微机常用的输出设备有显示终端CRT、打印机、激光印字机、绘图仪及磁带、光盘机等。
    (cpu=控制器+运算器主板=I/O总线,输入输出系统
    存储器=内存+硬盘
    I/O设备:键盘,鼠标,扫描仪,显示器等等)
    软件编辑
    软件概述
    计算机软件 [1] (ComputerSoftware)是指计算机系统中的程序及其文档。程序是计算任务的处理对象和处理规则的描述;文档是为了便于了解程序所需的阐述性资料。程序必须装入机器内部才能工作,文档一般是给人看的,不一定装入机器。软件是用户与硬件之间的接口界面。用户主要是通过软件与计算机进行交流。软件是计算机系统设计的重要依据。为了方便用户,为了使计算机系统具有较高的总体效用,在设计计算机系统时,必须通盘考虑软件与硬件的结合,以及用户的要求和软件的要求。软件的正确含义应该是:
    (1)运行时,能够提供所要求功能和性能的指令或计算机程序集合。
    (2)程序能够满意地处理信息的数据结构。
    (3)描述程序功能需求以及程序如何操作和使用所要求的文档。

软件具有与硬件不同的特点:

(1)表现形式不同硬件有形,有色,有味,看得见,摸得着,闻得到。而软件无形,无色,无味,看不见,摸不着,闻不到。软件大多存在人们的脑袋里或纸面上,它的正确与否,是好是坏,一直要到程序在机器上运行才能知道。这就给设计、生产和管理带来许多困难。

(2)生产方式不同软件是开发,是人的智力的高度发挥,不是传统意义上的硬件制造。尽管软件开发与硬件制造之间有许多共同点,但这两种活动是根本不同的。

(3)要求不同硬件产品允许有误差,而软件产品却不允许有误差。

(4)维护不同硬件是要用旧用坏的,在理论上,软件是不会用旧用坏的,但在实际上,软件也会变旧变坏。因为在软件的整个生存期中,一直处于改变维护状态。

计算机软件分为系统软件和应用软件,如果把计算机比喻为一个人的话,那么硬件就表示人的身躯。而软件则表示人的思想、灵魂。一台没有安装任何软件的计算机我们把它称之为“裸机”。

小白学堂,学的不止是技术,更是前程

关于我们免责声明